@etherisc/gif-next 0.0.2-fc8b370-882 → 0.0.2-fcbeffe-064

package/contracts/product/IClaimService.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IInstance} from "../instance/IInstance.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {NftId} from "../type/NftId.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";
+
+/// @dev gif service responsible for creating claims and payouts
+/// only product components may call transaction functions
+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 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);
+
+    error ErrorClaimServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
+    error ErrorClaimServicePolicyNotOpen(NftId policyNftId);
+    error ErrorClaimServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
+
+    error ErrorClaimServiceClaimWithOpenPayouts(NftId policyNftId, ClaimId claimId, uint8 openPayouts);
+    error ErrorClaimServiceClaimWithMissingPayouts(NftId policyNftId, ClaimId claimId, Amount claimAmount, Amount paidAmount);
+    error ErrorClaimServiceClaimNotInExpectedState(NftId policyNftId, ClaimId claimId, StateId expectedState, 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
+    function submit(
+        NftId policyNftId, 
+        Amount claimAmount,
+        bytes memory claimData
+    ) 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(
+        NftId policyNftId, 
+        ClaimId claimId,
+        bytes memory data // claim processing data
+    ) 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(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount confirmedAmount,
+        bytes memory data // claim processing data
+    ) external;
+
+
+    /// @dev closes the specified claim
+    /// function can only be called by product, policy needs to match with calling product
+    function close(
+        NftId policyNftId, 
+        ClaimId claimId
+    ) external;
+
+
+    /// @dev creates a new payout for the specified claim
+    /// 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(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        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
+    function processPayout(
+        NftId policyNftId, 
+        PayoutId payoutId
+    ) external;
+}

package/contracts/product/IPolicyService.sol

@@ -0,0 +1,78 @@
+// 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 {
+
+    error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
+    error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
+    error ErrorPolicyServicePolicyStateNotCollateralizedOrApplied(NftId applicationNftId);
+
+    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 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,
+        Timestamp activateAt
+    ) external;
+
+    /// @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
+    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
+    /// 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;
+
+    /// @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;
+
+}

package/contracts/product/IPricingService.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Seconds} from "../type/Seconds.sol";
+import {NftId} from "../type/NftId.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {Amount} from "../type/Amount.sol";
+
+import {IService} from "./IApplicationService.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+
+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
+            );
+
+    function calculatePremium(
+        NftId productNftId,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        external
+        view
+        returns (IPolicy.Premium memory premium);
+}

package/contracts/product/IProductComponent.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+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";
+import {ReferralId} from "../type/Referral.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {Seconds} from "../type/Seconds.sol";
+
+interface IProductComponent is
+    IInstanceLinkedComponent
+{
+
+    function calculatePremium(
+        Amount sumInsuredAmount,
+        RiskId riskId,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    ) external view returns (Amount premiumAmount);
+
+    function calculateNetPremium(
+        Amount sumInsuredAmount,
+        RiskId riskId,
+        Seconds lifetime,
+        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

@@ -0,0 +1,33 @@
+// 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 {
+
+    function createRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRiskState(
+        RiskId riskId,
+        StateId newState
+    ) external;
+}