@etherisc/gif-next 0.0.2-db1e1e4-828 → 0.0.2-db81915-875

package/contracts/instance/service/ClaimService.sol

@@ -22,18 +22,19 @@ import {TokenHandler} from "../../shared/TokenHandler.sol";
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
 
+import {Amount, AmountLib} from "../../types/Amount.sol";
 import {Timestamp, TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {UFixed, UFixedLib} from "../../types/UFixed.sol";
 import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
 import {ObjectType, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, CLAIM, BUNDLE} from "../../types/ObjectType.sol";
-import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE, CLOSED} from "../../types/StateId.sol";
+import {SUBMITTED, ACTIVE, KEEP_STATE, DECLINED, CONFIRMED, CLOSED} from "../../types/StateId.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {Fee, FeeLib} from "../../types/Fee.sol";
 import {ReferralId} from "../../types/Referral.sol";
 import {RiskId} from "../../types/RiskId.sol";
 import {StateId} from "../../types/StateId.sol";
-import {ClaimId} from "../../types/ClaimId.sol";
-import {PayoutId} from "../../types/PayoutId.sol";
+import {ClaimId, ClaimIdLib} from "../../types/ClaimId.sol";
+import {PayoutId, PayoutIdLib} from "../../types/PayoutId.sol";
 import {Version, VersionLib} from "../../types/Version.sol";
 
 import {ComponentService} from "../base/ComponentService.sol";
@@ -50,6 +51,7 @@ contract ClaimService is
     IClaimService
 {
 
+    IPoolService internal _poolService;
 
     function _initialize(
         address owner, 
@@ -65,6 +67,9 @@ contract ClaimService is
         (registryAddress, initialOwner) = abi.decode(data, (address, address));
 
         initializeService(registryAddress, address(0), owner);
+
+        _poolService = IPoolService(getRegistry().getServiceAddress(POOL(), getVersion().toMajorPart()));
+
         registerInterface(type(IClaimService).interfaceId);
     }
 
@@ -74,67 +79,127 @@ contract ClaimService is
     }
 
 
-    function createClaim(
+    function submit(
+        IInstance instance,
         NftId policyNftId, 
-        uint256 claimAmount,
+        ClaimId claimId, 
+        Amount claimAmount,
         bytes memory claimData
     )
         external
         virtual
-        returns (ClaimId)
+        // TODO add restricted and grant to policy service
     {
-
+        instance.createClaim(
+            policyNftId, 
+            claimId, 
+            IPolicy.ClaimInfo(
+                claimAmount,
+                AmountLib.zero(), // paidAmount
+                0, // payoutsCount
+                0, // openPayoutsCount
+                claimData,
+                TimestampLib.zero())); // closedAt
     }
 
 
-    function confirmClaim(NftId policyNftId, ClaimId claimId, uint256 claimAmount)
+    function confirm(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount confirmedAmount
+    )
         external
         virtual
-        // solhint-disable-next-line no-empty-blocks
     {
-
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
+        claimInfo.claimAmount = confirmedAmount;
+        instance.updateClaim(policyNftId, claimId, claimInfo, CONFIRMED());
     }
 
-
-    function declineClaim(NftId policyNftId, ClaimId claimId)
+    function decline(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId
+    )
         external
         virtual
-        // solhint-disable-next-line no-empty-blocks
     {
-
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
+        claimInfo.closedAt = TimestampLib.blockTimestamp();
+        instance.updateClaim(policyNftId, claimId, claimInfo, DECLINED());
     }
 
 
-    function closeClaim(NftId policyNftId, ClaimId claimId)
+    function close(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId
+    )
         external
         virtual
-        // solhint-disable-next-line no-empty-blocks
     {
-
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, CONFIRMED());
+
+        // check claim has no open payouts
+        if(claimInfo.openPayoutsCount > 0) {
+            revert ErrorClaimServiceClaimWithOpenPayouts(
+                policyNftId, 
+                claimId, 
+                claimInfo.openPayoutsCount);
+        }
+
+        // check claim paid amount matches with claim amount
+        if(claimInfo.paidAmount.toInt() < claimInfo.claimAmount.toInt()) {
+            revert ErrorClaimServiceClaimWithMissingPayouts(
+                policyNftId, 
+                claimId, 
+                claimInfo.claimAmount,
+                claimInfo.paidAmount);
+        }
+
+        claimInfo.closedAt = TimestampLib.blockTimestamp();
+        instance.updateClaim(policyNftId, claimId, claimInfo, CLOSED());
     }
 
 
     function createPayout(
+        IInstance instance,
         NftId policyNftId, 
-        ClaimId claimId,
-        uint256 payoutAmount,
+        PayoutId payoutId,
+        Amount payoutAmount,
         bytes calldata payoutData
     )
         external
         virtual
-        returns(PayoutId payoutId)
-        // solhint-disable-next-line no-empty-blocks
+        // TODO add restricted and grant to policy service
     {
-
+        instance.createPayout(
+            policyNftId, 
+            payoutId, 
+            IPolicy.PayoutInfo(
+                payoutId.toClaimId(),
+                payoutAmount,
+                payoutData,
+                TimestampLib.zero()));
     }
 
 
-    function payoutExecuted(
+    function processPayout(
+        IInstance instance,
+        InstanceReader instanceReader,
         NftId policyNftId, 
         PayoutId payoutId
     )
         external
         virtual
+        returns (
+            Amount amount,
+            bool payoutIsClosingClaim
+        )
         // solhint-disable-next-line no-empty-blocks
     {
 
@@ -143,6 +208,29 @@ contract ClaimService is
 
     // internal functions
 
+    function _verifyClaim(
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId, 
+        StateId expectedState
+    )
+        internal
+        view
+        returns (
+            IPolicy.ClaimInfo memory claimInfo
+        )
+    {
+        // check claim is created state
+        StateId claimState = instanceReader.getClaimState(policyNftId, claimId);
+        if(claimState != expectedState) {
+            revert ErrorClaimServiceClaimNotInExpectedState(
+                policyNftId, claimId, expectedState, claimState);
+        }
+
+        // get claim info
+        claimInfo = instanceReader.getClaimInfo(policyNftId, claimId);
+    }
+
     function _getAndVerifyInstanceAndProduct() internal view returns (Product product) {
         IRegistry.ObjectInfo memory productInfo;
         (, productInfo,) = _getAndVerifyComponentInfoAndInstance(PRODUCT());

package/contracts/instance/service/DistributionService.sol

@@ -155,22 +155,18 @@ contract DistributionService is
         }
         
         distributorType = DistributorTypeLib.toDistributorType(distributionNftId, name);
-        Key32 key32 = distributorType.toKey32();
-
-        if(!instance.exists(key32)) {
-            IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
-                name,
-                minDiscountPercentage,
-                maxDiscountPercentage,
-                commissionPercentage,
-                maxReferralCount,
-                maxReferralLifetime,
-                allowSelfReferrals,
-                allowRenewals,
-                data);
-
-            instance.createDistributorType(key32, info);
-        }
+        IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
+            name,
+            minDiscountPercentage,
+            maxDiscountPercentage,
+            commissionPercentage,
+            maxReferralCount,
+            maxReferralLifetime,
+            allowSelfReferrals,
+            allowRenewals,
+            data);
+
+        instance.createDistributorType(distributorType, info);
     }
 
     function createDistributor(
@@ -267,7 +263,7 @@ contract DistributionService is
             data
         );
 
-        instance.createReferral(referralId.toKey32(), info);
+        instance.createReferral(referralId, info);
         return referralId;
     }
 
@@ -308,7 +304,7 @@ contract DistributionService is
 
         if (isReferral) {
             referralInfo.usedReferrals += 1;
-            instance.updateReferral(referralId.toKey32(), referralInfo, KEEP_STATE());
+            instance.updateReferral(referralId, referralInfo, KEEP_STATE());
 
             if (commissionAmount > 0) {
                 distributorInfo.sumCommisions += commissionAmount;

package/contracts/instance/service/IApplicationService.sol

@@ -2,24 +2,20 @@
 pragma solidity ^0.8.19;
 
 import {IPolicy} from "../module/IPolicy.sol";
-import {IRisk} from "../module/IRisk.sol";
 import {IService} from "../../shared/IService.sol";
 
 import {NftId} from "../../types/NftId.sol";
+import {ObjectType} from "../../types/ObjectType.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";
 
 /// @dev gif service responsible for creating applications
 /// only product components may call transaction functions
 interface IApplicationService is IService {
     
-    error IApplicationServicePolicyNotApplied(NftId applicationNftId);
-    error IApplicationServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
+    error ErrorApplicationServiceNotProduct(NftId callerNftId, ObjectType callerType);
+    error ErrorApplicationServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
 
     /// @dev creates a new application based on the specified attributes
     /// may only be called by a product component

package/contracts/instance/service/IBundleService.sol

@@ -21,6 +21,9 @@ interface IBundleService is IService {
     error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, uint capacityAmount, uint collateralAmount);
     error ErrorBundleServiceBundleWithOpenPolicies(NftId bundleNftId, uint256 openPoliciesCount);
 
+    error ErrorBundleServiceBundleUnknown(NftId bundleNftId);
+    error ErrorBundleServiceBundlePoolMismatch(NftId expectedPoolNftId, NftId bundlePoolNftId);
+
     /// @dev create a new bundle for the specified attributes
     /// may only be called by pool service
     function create(

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/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,19 @@ 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 ErrorPolicyServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
+    error ErrorPolicyServicePolicyNotOpen(NftId policyNftId);
+    error ErrorPolicyServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
+
     error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
     error ErrorIPolicyServicePremiumAlreadyPaid(NftId policyNftId, uint256 premiumPaidAmount);
     error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
@@ -24,22 +39,22 @@ 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);
 
     /// @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 +78,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,