@etherisc/gif-next 0.0.2-ce87da3-250 → 0.0.2-ceb30b2-601

package/contracts/instance/service/IClaimService.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {IRisk} from "../module/IRisk.sol";
+import {IInstance} from "../IInstance.sol";
+import {InstanceReader} from "../InstanceReader.sol";
 import {IService} from "../../shared/IService.sol";
 
+import {Amount} from "../../types/Amount.sol";
 import {ClaimId} from "../../types/ClaimId.sol";
 import {PayoutId} from "../../types/PayoutId.sol";
 import {NftId} from "../../types/NftId.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
 import {StateId} from "../../types/StateId.sol";
 import {Timestamp} from "../../types/Timestamp.sol";
 import {UFixed} from "../../types/UFixed.sol";
@@ -20,42 +20,71 @@ 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);
+
+    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 createClaim(
+    function submit(
         NftId policyNftId, 
-        uint256 claimAmount,
+        Amount claimAmount,
         bytes memory claimData
-    ) external returns (ClaimId);
+    ) external returns (ClaimId claimId);
 
-    /// @dev confirms the specified claim and fixes the final claim amount
+    /// @dev declines the specified claim
     /// function can only be called by product, policy needs to match with calling product
-    function confirmClaim(NftId policyNftId, ClaimId claimId, uint256 claimAmount) external;
+    function decline(
+        NftId policyNftId, 
+        ClaimId claimId) external;
 
-    /// @dev declares the claim as invalid, no payout(s) will be made
+    /// @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 declineClaim(NftId policyNftId, ClaimId claimId) external;
+    function confirm(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount confirmedAmount
+    ) external;
 
-    /// @dev closes the claim
-    /// a claim may only be closed once all existing payouts have been executed and the sum of the paid out amounts has reached the claim amount
+    /// @dev closes the specified claim
     /// function can only be called by product, policy needs to match with calling product
-    function closeClaim(NftId policyNftId, ClaimId claimId) external; 
+    function close(
+        NftId policyNftId, 
+        ClaimId claimId
+    ) external;
 
-    /// @dev create a new payout for the specified policy and claim
+
+    /// @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,
-        uint256 payoutAmount,
-        bytes calldata payoutData
-    ) external returns (PayoutId payoutId);
-
-    /// @dev callback function to confirm transfer of payout token to beneficiary
-    /// allows claim service to update claims/payout book keeping
-    /// only pool service can confirm executed payout
-    function payoutExecuted(
+        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/instance/service/IDistributionService.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.19;
 
 import {NftId} from "../../types/NftId.sol";
 import {Fee} from "../../types/Fee.sol";
+import {IPolicy} from "../module/IPolicy.sol";
 import {IService} from "../../shared/IService.sol";
 import {UFixed} from "../../types/UFixed.sol";
 import {DistributorType} from "../../types/DistributorType.sol";
@@ -11,6 +12,7 @@ import {Timestamp} from "../../types/Timestamp.sol";
 
 
 interface IDistributionService is IService {
+    error ErrorDistributionServiceCallerNotRegistered(address caller);
     error ErrorIDistributionServiceParentNftIdNotInstance(NftId nftId, NftId parentNftId);
     error ErrorIDistributionServiceCallerNotDistributor(address caller);
     error ErrorIDistributionServiceInvalidReferralId(ReferralId referralId);
@@ -20,8 +22,22 @@ interface IDistributionService is IService {
     error ErrorIDistributionServiceExpiryTooLong(uint256 maxReferralLifetime, uint256 expiryAt);
     error ErrorIDistributionServiceInvalidReferral(string code);
     error ErrorIDistributionServiceExpirationInvalid(Timestamp expiryAt);
+    error ErrorIDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
+    error ErrorIDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
+    error ErrorIDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
+    error ErrorIDistributionServiceFeeCalculationMismatch(
+                uint256 distributionFeeFixAmount,
+                uint256 distributionFeeVarAmount,
+                uint256 distributionOwnerFeeFixAmount,
+                uint256 distributionOwnerFeeVarAmount,
+                uint256 commissionAmount,
+                uint256 discountAmount
+            );
+    error ErrorIDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
+    error ErrorIDistributionServiceInvalidFeeTransferred(uint256 transferredDistributionFeeAmount, uint256 expectedDistributionFeeAmount);
 
     function setFees(
+        Fee memory minDistributionOwnerFee,
         Fee memory distributionFee
     ) external;
     
@@ -64,15 +80,17 @@ interface IDistributionService is IService {
 
     /// @dev callback from product service when selling a policy for a specific referralId
     function processSale(
+        NftId distributionNftId,
         ReferralId referralId,
-        uint256 premiumAmount
+        IPolicy.Premium memory premium,
+        uint256 transferredDistributionFeeAmount
     ) external;
 
     function calculateFeeAmount(
         NftId distributionNftId,
         ReferralId referralId,
-        uint256 netPremiumAmount
-    ) external view returns (uint256 feeAmount);
+        IPolicy.Premium memory premium
+    ) external view returns (IPolicy.Premium memory finalPremium);
 
     function referralIsValid(
         NftId distributorNftId,

package/contracts/instance/service/IPolicyService.sol

@@ -4,16 +4,23 @@ pragma solidity ^0.8.19;
 import {IRisk} from "../module/IRisk.sol";
 import {IService} from "../../shared/IService.sol";
 
+import {Amount} from "../../types/Amount.sol";
+import {ClaimId} from "../../types/ClaimId.sol";
 import {NftId} from "../../types/NftId.sol";
+import {PayoutId} from "../../types/PayoutId.sol";
 import {ReferralId} from "../../types/Referral.sol";
 import {RiskId} from "../../types/RiskId.sol";
+import {Seconds} from "../../types/Seconds.sol";
 import {StateId} from "../../types/StateId.sol";
 import {Timestamp} from "../../types/Timestamp.sol";
 import {UFixed} from "../../types/UFixed.sol";
 import {Fee} from "../../types/Fee.sol";
 
 interface IPolicyService is IService {
-    
+
+    error ErrorPolicyServiceProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
+    error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
+
     error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
     error ErrorIPolicyServicePremiumAlreadyPaid(NftId policyNftId, uint256 premiumPaidAmount);
     error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
@@ -23,25 +30,28 @@ interface IPolicyService is IService {
     error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
     error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
 
-    /// @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;
+    error ErrorIPolicyServicePremiumMismatch(NftId policyNftId, uint256 expectedPremiumAmount, uint256 recalculatedPremiumAmount);
+    error ErrorPolicyServiceTransferredPremiumMismatch(NftId policyNftId, uint256 expectedPremiumAmount, uint256 transferredPremiumAmount);
 
-    /// @dev underwrites the policy represented by {policyNftId}
-    /// sets the policy state to underwritten
+    /// @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 underwritten in applied state
-    /// only the related product may underwrite an application
-    function underwrite(
+    /// 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;
 
@@ -60,25 +70,6 @@ interface IPolicyService is IService {
     /// this function can only be called by a product. the policy needs to match with the calling product
     function close(NftId policyNftId) external;
 
-    /// @dev calculates the total premium amount for the specified attributes
-    /// also returns the various fees included in the total premium amount
-    function calculatePremium(
-        RiskId riskId,
-        uint256 sumInsuredAmount,
-        uint256 lifetime,
-        bytes memory applicationData,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        external
-        view
-        returns (
-            uint256 premiumAmount,
-            uint256 productFeeAmount,
-            uint256 poolFeeAmount,
-            uint256 bundleFeeAmount,
-            uint256 distributionFeeAmount
-        );
 
     // TODO move function to pool service
     function calculateRequiredCollateral(

package/contracts/instance/service/IPoolService.sol

@@ -1,20 +1,144 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {NftId} from "../../types/NftId.sol";
+import {Amount} from "../../types/Amount.sol";
 import {Fee} from "../../types/Fee.sol";
-import {StateId} from "../../types/StateId.sol";
-import {IService} from "../../shared/IService.sol";
+import {NftId} from "../../types/NftId.sol";
+import {PayoutId} from "../../types/PayoutId.sol";
 import {IBundle} from "../module/IBundle.sol";
 import {IInstance} from "../../instance/IInstance.sol";
+import {IPolicy} from "../module/IPolicy.sol";
+import {IService} from "../../shared/IService.sol";
+import {RoleId} from "../../types/RoleId.sol";
+import {Seconds} from "../../types/Seconds.sol";
+import {StateId} from "../../types/StateId.sol";
 
 interface IPoolService is IService {
 
+    event LogPoolServiceMaxCapitalAmountUpdated(NftId poolNftId, uint256 previousMaxCapitalAmount, uint256 currentMaxCapitalAmount);
+    event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
+
+    event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+    event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+
+    error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
+    error ErrorPoolServiceBundlePoolMismatch(NftId bundlePoolNftId, NftId productPoolNftId);
+    error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
+
+    /// @dev registers a new pool with the registry service
     function register(address poolAddress) external returns(NftId);
 
+    /// @dev defines the required role for bundle owners for the calling pool
+    /// default implementation returns PUBLIC ROLE
+    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
+
+    /// @dev sets the max capital amount for the calling pool
+    function setMaxCapitalAmount(uint256 maxCapitalAmount) external;
+
+    /// @dev set pool sepecific fees
     function setFees(
         Fee memory poolFee,
         Fee memory stakingFee,
         Fee memory performanceFee
     ) external;
+
+
+    /// @dev locks required collateral to cover the specified application (and turn it into a policy)
+    /// - retention level == 1: the full collateral amount will be locked by the specified bundle
+    /// - retention level < 1: a part of the coverage is provided by the specified bundle, the rest by the pool component
+    /// in which case the pool component might hold a re-insurance policy
+    /// may only be called by the policy service for unlocked pool components
+    function lockCollateral(
+        IInstance instance, 
+        NftId productNftId,
+        NftId applicationNftId,
+        IPolicy.PolicyInfo memory applicationInfo,
+        uint256 premiumAmount
+    ) external;
+
+
+    /// @dev releases the remaining collateral linked to the specified policy
+    /// may only be called by the policy service for unlocked pool components
+    function releaseCollateral(
+        IInstance instance, 
+        NftId policyNftId, 
+        IPolicy.PolicyInfo memory policyInfo
+    ) external;
+
+
+    /// @dev reduces the locked collateral in the bundle associated with the specified policy
+    /// every payout of a policy reduces the collateral by the payout amount
+    /// may only be called by the claim service for unlocked pool components
+    function reduceCollateral(
+        IInstance instance, 
+        NftId policyNftId, 
+        IPolicy.PolicyInfo memory policyInfo,
+        Amount payoutAmount
+    ) external;
+
+
+    /// @dev create a new bundle for the provided parameters
+    /// staking fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
+    function createBundle(
+        address owner, // initial bundle owner
+        Fee memory fee, // fees deducted from premium that go to bundle owner
+        Amount stakingAmount, // staking amount - staking fees result in initial bundle capital
+        Seconds lifetime, // initial duration for which new policies are covered
+        bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
+    )
+        external 
+        returns(NftId bundleNftId); // the nft id of the newly created bundle
+
+
+    /// @dev closes the specified bundle
+    /// only open bundles (active or locked) may be closed
+    /// to close a bundle it may not have any non-closed polices attached to it
+    /// bundle fees and remaining capital (after deduction of the performance fee) will be transferred to the bundle owner
+    /// may only be called by registered and unlocked pool components
+    function closeBundle(NftId bundleNftId) external;
+
+    /// @dev processes the sale of a bundle and track the pool fee and bundle fee amounts
+    function processSale(NftId bundleNftId, IPolicy.Premium memory premium, uint256 actualAmountTransferred) external;
+
+    /// @dev increase stakes for bundle
+    /// staking fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
+    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+
+    /// @dev decrease stakes for bundle
+    /// performance fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
+    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+
+    // /// @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;
+
+    // /// @dev creates payout request to be processed by pool
+    // /// processing(?) fees will be deducted by the pool service from the staking amount
+    // /// may only be called by claim service
+    // function requestPayout(
+    //     IInstance instance,
+    //     PayoutId payoutId
+    // ) external; 
 }