@etherisc/gif-next 0.0.2-fbe6493-116 → 0.0.2-fc41a4e-906

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,14 @@ 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 ErrorApplicationServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
+    error ErrorApplicationServiceRiskUnknown(RiskId riskId, NftId productNftId);
+    error ErrorApplicationServiceRiskPaused(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,24 +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
@@ -47,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(
@@ -59,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(
@@ -77,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(
@@ -90,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
@@ -97,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,37 +1,40 @@
 // 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 LogPolicyServicePolicyActivatedUpdated(NftId policyNftId, Timestamp activatedAt);
+    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);
+    event LogPolicyServicePolicyClosed(NftId policyNftId);
+
     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 ErrorPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
-    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId, Amount premiumPaidAmount);
     error ErrorPolicyServicePolicyNotActivated(NftId policyNftId);
-    error ErrorPolicyServicePolicyAlreadyClosed(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 ErrorPolicyServicePolicyNotCloseable(NftId policyNftId);
+
     error ErrorPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
-    error ErrorPolicyServicePremiumNotFullyPaid(NftId policyNftId, Amount premiumAmount, Amount premiumPaidAmount);
+    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);
@@ -40,45 +43,52 @@ interface IPolicyService is IService {
     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 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.
-    /// sets the policy state to collateralized
-    /// 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
+    /// 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,
-        bool requirePremiumPayment,
         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 (must be in COLLATERALIZED or ACTIVE state)
+    /// @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. 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);
 
-    /// @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,15 +14,16 @@ 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 ErrorPricingServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
+    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 +36,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}

@@ -1,23 +1,23 @@
 // 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 {
+interface IRiskService is IService {
 
+    error ErrorRiskServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
+
+    /// @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(