@etherisc/gif-next 0.0.2-f9bc4c7-556 → 0.0.2-fa35bce-363

package/contracts/product/IApplicationService.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.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";
+
+/// @dev gif service responsible for creating applications
+/// only product components may call transaction functions
+interface IApplicationService is IService {
+    
+    event LogApplicationServiceApplicationCreated(
+        NftId applicationNftId,
+        NftId productNftId,
+        NftId bundleNftId, 
+        RiskId riskId,
+        ReferralId referralId,
+        address applicationOwner,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime);
+    event LogApplicationServiceApplicationRenewed(NftId policyNftId, NftId bundleNftId);
+    event LogApplicationServiceApplicationAdjusted(
+        NftId applicationNftId, 
+        NftId bundleNftId, 
+        RiskId riskId, 
+        ReferralId referralId, 
+        Amount sumInsuredAmount, 
+        Seconds lifetime);
+    event LogApplicationServiceApplicationRevoked(NftId applicationNftId);
+
+    // _checkLinkedApplicationParameters
+    error ErrorApplicationServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
+    error ErrorApplicationServiceRiskUnknown(RiskId riskId, NftId productNftId);
+    error ErrorApplicationServiceRiskLocked(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
+    function create(
+        address applicationOwner,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime,
+        NftId bundleNftId,
+        ReferralId referralId,
+        bytes memory applicationData
+    ) external returns (NftId applicationNftId);
+
+    /// @dev updates application attributes
+    /// may only be called while the application is in applied state
+    /// may only be called by the referenced product related to applicationNftId
+    function adjust(
+        NftId applicationNftId,
+        RiskId riskId,
+        NftId bundleNftId,
+        ReferralId referralId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
+        bytes memory applicationData
+    ) external;
+
+    /// @dev creates a new application that extends the provided policy
+    /// lifetime will seamlessly extend referenced policy, for closed policies
+    /// lifetime will start at underwriting time
+    /// product will need to limit the time window for renewal as underwriting
+    /// will lock the collateral at underwriting time which might be earlier than activation time
+    /// policyNftId needs to refer to an underwritten (or active or closed) policy
+    /// may only be called by the referenced product related to policyNftId
+    function renew(
+        NftId policyNftId, // policy to be renewd (renewal inherits policy attributes)
+        NftId bundleNftId // will likely need a newer bundle for underwriting
+    ) external returns (NftId applicationNftId);
+
+    /// @dev revokes the application represented by {policyNftId}
+    /// an application can only be revoked in applied state
+    /// only the application holder may revoke an application
+    function revoke(NftId policyNftId) external;
+}

package/contracts/product/IClaimService.sol

@@ -0,0 +1,136 @@
+// 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 LogClaimServiceClaimCancelled(NftId policyNftId, ClaimId claimId);
+
+    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, 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
+    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 cancels a confirmed claim before it has been fully paid out. 
+    /// Can only be called when there are not pending payouts
+    /// function can only be called by product, policy needs to match with calling product
+    function cancelConfirmedClaim(
+        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 returns (Amount netPayoutAmount, Amount processingFeeAmount);
+
+    /// @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

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {NftId} from "../type/NftId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.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 LogPolicyServiceMaxPremiumAmountExceeded(NftId policyNftId, Amount maxPremiumAmount, Amount premiumAmount);
+    error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
+    error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
+    error ErrorPolicyServicePolicyStateNotCollateralized(NftId applicationNftId);
+    error ErrorPolicyServicePolicyAlreadyActivated(NftId policyNftId);
+
+    error ErrorPolicyServicePolicyNotActivated(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 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 creates the policy from {applicationNftId}. 
+    /// @param applicationNftId the application NftId
+    /// @param activateAt the timestamp when the policy should be activated
+    /// @param maxPremiumAmount the maximum premium amount that the policy holder is willing to pay
+    /// During policy creation, the effective premium amount is calculated based on the provided parameters. If this
+    /// amount is higher than the maxPremiumAmount, the function will revert.
+    /// 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
+    /// @return premiumAmount the effective premium amount
+    function createPolicy(
+        NftId applicationNftId,
+        Timestamp activateAt,
+        Amount maxPremiumAmount
+    )
+        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 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 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
+    /// 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

@@ -0,0 +1,40 @@
+// 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 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,
+        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,62 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.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";
+
+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,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        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,
+        Seconds lifetime,
+        bytes memory applicationData
+    ) external view returns (Amount netPremiumAmount);    
+
+
+    /// @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/IRiskService.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+
+import {NftId} from "../type/NftId.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {StateId} from "../type/StateId.sol";
+
+interface IRiskService is IService {
+
+    event LogRiskServiceRiskCreated(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskUpdated(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskLocked(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskUnlocked(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskClosed(NftId productNftId, RiskId riskId);
+    
+    error ErrorRiskServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
+    error ErrorRiskServiceRiskNotActive(NftId productNftId, RiskId riskId);
+    error ErrorRiskServiceUnknownRisk(NftId productNftId, RiskId riskId);
+    error ErrorRiskServiceRiskNotLocked(NftId productNftId, RiskId riskId);
+
+    /// @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(
+        bytes32 id,
+        bytes memory data
+    ) external returns (RiskId riskId);
+
+
+    function updateRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+    /// @dev Locks/unlocks the risk with the given id.
+    /// No new policies can be underwritten for a locked risk.
+    function setRiskLocked(
+        RiskId riskId,
+        bool locked
+    ) external;
+
+    /// @dev Close the risk with the given id.
+    function closeRisk(
+        RiskId riskId
+    ) external;
+}