@etherisc/gif-next 0.0.2-743affe-003 → 0.0.2-758fb77-627

package/contracts/product/IClaimService.sol

@@ -0,0 +1,122 @@
+// 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 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, Amount processingFeeAmount);
+
+    error ErrorClaimServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
+    error ErrorClaimServicePolicyNotOpen(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 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);
+
+
+    /// @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 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(
+        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.
+    /// 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(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        bytes memory data
+    )
+        external
+        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
+    function processPayout(
+        NftId policyNftId, 
+        PayoutId payoutId
+    ) external;
+}

package/contracts/product/IPolicyService.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {NftId} from "../type/NftId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IPolicyService is IService {
+
+    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);
+    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);
+
+    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, 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;
+
+    /// @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 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
+    /// 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
+    /// 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(
+                Amount distributionFeeFixAmount,
+                Amount distributionFeeVarAmount,
+                Amount distributionOwnerFeeFixAmount,
+                Amount distributionOwnerFeeVarAmount,
+                Amount commissionAmount,
+                Amount discountAmount
+            );
+
+    function calculatePremium(
+        NftId productNftId,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        external
+        view
+        returns (IPolicy.PremiumInfo memory premium);
+}

package/contracts/product/IProductComponent.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.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/IRiskService.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 IRiskService 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;
+}