@etherisc/gif-next 0.0.2-b1fff40-773 → 0.0.2-b214449-558

package/contracts/product/ClaimServiceManager.sol

@@ -12,14 +12,14 @@ contract ClaimServiceManager is ProxyManager {
     /// @dev initializes proxy manager with service implementation 
     constructor(
         address authority, 
-        address registryAddress,
+        address registry,
         bytes32 salt
     ) 
-        ProxyManager(registryAddress)
     {
         ClaimService svc = new ClaimService{salt: salt}();
-        bytes memory data = abi.encode(registryAddress, address(this), authority);
-        IVersionable versionable = deployDetermenistic(
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
             data,
             salt);

package/contracts/product/IApplicationService.sol

@@ -15,8 +15,11 @@ 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);
+    // _checkLinkedApplicationParameters
+    error ErrorApplicationServiceRiskUnknown(RiskId riskId, NftId productNftId);
+    error ErrorApplicationServiceRiskPaused(RiskId riskId, NftId productNftId);
+    error ErrorApplicationServiceBundleUnknown(NftId bundleNftId, NftId poolNftId);
+    error ErrorApplicationServiceBundleLocked(NftId bundleNftId, NftId poolNftId);
 
     /// @dev creates a new application based on the specified attributes
     /// may only be called by a product component
@@ -24,6 +27,7 @@ interface IApplicationService is IService {
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,

package/contracts/product/IClaimService.sol

@@ -19,23 +19,33 @@ 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 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);
+    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);
 
-    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);
 
+    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
@@ -46,9 +56,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 +65,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 +91,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 +105,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
@@ -96,4 +126,10 @@ interface IClaimService is
         NftId policyNftId, 
         PayoutId payoutId
     ) external;
+
+    /// @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

@@ -1,78 +1,91 @@
 // 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 {InstanceReader} from "../instance/InstanceReader.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);
+
+    // TODO cleanup
+    // error ErrorPolicyServiceBalanceInsufficient(address policyOwner, uint256 premiumAmount, uint256 balance);
+    // error ErrorPolicyServiceAllowanceInsufficient(address policyOwner, address tokenHandler, uint256 premiumAmount, uint256 allowance);
 
-    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 ErrorPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId);
 
-    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 ErrorPolicyServicePolicyNotCloseable(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;
+    )
+        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
     /// 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. 
+    /// 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
-    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
+    /// @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);
+
+    /// @dev Returns true iff policy is closeable
+    function policyIsCloseable(InstanceReader instanceReader, NftId policyNftId) external view returns (bool isCloseable);
 }

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,11 +52,11 @@ 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
+    /// @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/{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,