@etherisc/gif-next 0.0.2-e922e07-736 → 0.0.2-e94f4c7-084

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,73 @@ interface IClaimService is
     IService
 {
 
+    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
     /// function can only be called by product, policy needs to match with calling product
-    function createClaim(
+    function submit(
+        IInstance instance,
         NftId policyNftId, 
-        uint256 claimAmount,
+        ClaimId claimId,
+        Amount claimAmount,
         bytes memory claimData
-    ) external returns (ClaimId);
+    ) external;
 
     /// @dev confirms the specified claim and fixes the final claim amount
     /// function can only be called by product, policy needs to match with calling product
-    function confirmClaim(NftId policyNftId, ClaimId claimId, uint256 claimAmount) external;
+    function confirm(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount claimAmount
+    ) external;
 
     /// @dev declares the claim as invalid, no payout(s) will be made
     /// function can only be called by product, policy needs to match with calling product
-    function declineClaim(NftId policyNftId, ClaimId claimId) external;
+    function decline(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId
+    ) 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
     /// function can only be called by product, policy needs to match with calling product
-    function closeClaim(NftId policyNftId, ClaimId claimId) external; 
+    function close(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId
+    ) external; 
 
-    /// @dev create a new payout for the specified policy and claim
+    /// @dev create a new payout for the specified policy
+    /// payoutId may be constructed using PayoutIdLib(claimId, payoutNo)
     /// function can only be called by product, policy needs to match with calling product
     function createPayout(
+        IInstance instance,
         NftId policyNftId, 
-        ClaimId claimId,
-        uint256 payoutAmount,
+        PayoutId payoutId,
+        Amount payoutAmount,
         bytes calldata payoutData
-    ) external returns (PayoutId payoutId);
+    ) external; 
 
     /// @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(
+    function processPayout(
+        IInstance instance,
+        InstanceReader instanceReader,
         NftId policyNftId, 
         PayoutId payoutId
-    ) external;
+    )
+        external 
+        returns (
+            Amount amount,
+            bool payoutIsClosingClaim
+        );
 
 }

package/contracts/instance/service/IDistributionService.sol

@@ -12,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);

package/contracts/instance/service/IPolicyService.sol

@@ -4,7 +4,10 @@ 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";
@@ -14,7 +17,20 @@ import {UFixed} from "../../types/UFixed.sol";
 import {Fee} from "../../types/Fee.sol";
 
 interface IPolicyService is IService {
-    
+
+    event LogPolicyServiceClaimSubmitted(NftId policyNftId, ClaimId claimId, Amount claimAmount);
+    event LogPolicyServiceClaimConfirmed(NftId policyNftId, ClaimId claimId, Amount confirmedAmount);
+    event LogPolicyServiceClaimDeclined(NftId policyNftId, ClaimId claimId);
+    event LogPolicyServiceClaimClosed(NftId policyNftId, ClaimId claimId);
+
+    event LogPolicyServicePayoutCreated(NftId policyNftId, PayoutId payoutId, Amount amount);
+    event LogPolicyServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount);
+
+    error ErrorPolicyServiceProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
+    error ErrorPolicyServicePolicyNotOpen(NftId policyNftId);
+    error ErrorPolicyServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
+    error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
+
     error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
     error ErrorIPolicyServicePremiumAlreadyPaid(NftId policyNftId, uint256 premiumPaidAmount);
     error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
@@ -24,22 +40,23 @@ interface IPolicyService is IService {
     error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
     error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
 
-    error ErrorIPolicyServicePremiumMismatch(NftId policyNftId, uint256 premiumAmount, uint256 recalculatedPremiumAmount);
+    error ErrorIPolicyServicePremiumMismatch(NftId policyNftId, uint256 expectedPremiumAmount, uint256 recalculatedPremiumAmount);
+    error ErrorPolicyServiceTransferredPremiumMismatch(NftId policyNftId, uint256 expectedPremiumAmount, uint256 transferredPremiumAmount);
 
     /// @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 underwrites the policy represented by {policyNftId}
+    /// @dev collateralizes the policy represented by {policyNftId}
     /// sets the policy state to underwritten
     /// 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(
+    /// only the related product may collateralize an application
+    function collateralize(
         NftId policyNftId,
         bool requirePremiumPayment,
         Timestamp activateAt
@@ -63,6 +80,56 @@ 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 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 submitClaim(
+        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 declineClaim(
+        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 confirmClaim(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount confirmedAmount
+    ) external;
+
+    /// @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;
+
+    /// @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;
+
     // TODO move function to pool service
     function calculateRequiredCollateral(
         UFixed collateralizationLevel, 

package/contracts/instance/service/IPoolService.sol

@@ -1,20 +1,102 @@
 // 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 {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 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);
 }