@etherisc/gif-next 0.0.2-d48ae55-246 → 0.0.2-d53bd1e-732

package/contracts/product/ClaimService.sol

@@ -0,0 +1,442 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IRisk} from "../instance/module/IRisk.sol";
+import {IService} from "./IApplicationService.sol";
+
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IProductComponent} from "./IProductComponent.sol";
+import {Product} from "./Product.sol";
+import {IPoolComponent} from "../pool/IPoolComponent.sol";
+import {IDistributionComponent} from "../distribution/IDistributionComponent.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IRisk} from "../instance/module/IRisk.sol";
+import {IBundle} from "../instance/module/IBundle.sol";
+import {IProductService} from "./IProductService.sol";
+
+import {TokenHandler} from "../shared/TokenHandler.sol";
+
+import {IVersionable} from "../shared/IVersionable.sol";
+import {Versionable} from "../shared/Versionable.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Timestamp, TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+import {Blocknumber, blockNumber} from "../type/Blocknumber.sol";
+import {ObjectType, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, CLAIM, BUNDLE} from "../type/ObjectType.sol";
+import {SUBMITTED, ACTIVE, KEEP_STATE, DECLINED, CONFIRMED, CLOSED, PAID} from "../type/StateId.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {StateId} from "../type/StateId.sol";
+import {ClaimId, ClaimIdLib} from "../type/ClaimId.sol";
+import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+
+import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IBundleService} from "../pool/IBundleService.sol";
+import {IClaimService} from "./IClaimService.sol";
+import {IPoolService} from "../pool/IPoolService.sol";
+import {IService} from "../shared/IService.sol";
+import {Service} from "../shared/Service.sol";
+
+
+contract ClaimService is 
+    ComponentVerifyingService, 
+    IClaimService
+{
+
+    IPoolService internal _poolService;
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        virtual override
+        initializer()
+    {
+        (
+            address registryAddress,, 
+            //address managerAddress
+            address authority
+        ) = abi.decode(data, (address, address, address));
+
+        initializeService(registryAddress, authority, owner);
+
+        _poolService = IPoolService(getRegistry().getServiceAddress(POOL(), getVersion().toMajorPart()));
+
+        registerInterface(type(IClaimService).interfaceId);
+    }
+
+    function submit(
+        NftId policyNftId, 
+        Amount claimAmount,
+        bytes memory claimData // claim submission data
+    )
+        external
+        virtual
+        returns (ClaimId claimId)
+    {
+        (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        ) = _verifyCallerWithPolicy(policyNftId);
+
+        // check policy is in its active period
+        if(policyInfo.activatedAt.eqz() || TimestampLib.blockTimestamp() >= policyInfo.expiredAt) {
+            revert ErrorClaimServicePolicyNotOpen(policyNftId);
+        }
+
+        // check policy including this claim is still within sum insured
+        if(policyInfo.payoutAmount + claimAmount > policyInfo.sumInsuredAmount) {
+            revert ErrorClaimServiceClaimExceedsSumInsured(
+                policyNftId, 
+                policyInfo.sumInsuredAmount,
+                AmountLib.toAmount(policyInfo.payoutAmount.toInt() + claimAmount.toInt()));
+        }
+
+        // create new claim
+        claimId = ClaimIdLib.toClaimId(policyInfo.claimsCount + 1);
+        instance.getInstanceStore().createClaim(
+            policyNftId, 
+            claimId, 
+            IPolicy.ClaimInfo(
+                claimAmount,
+                AmountLib.zero(), // paidAmount
+                0, // payoutsCount
+                0, // openPayoutsCount
+                claimData, // claim submission data
+                "", // claim processing data
+                TimestampLib.zero())); // closedAt
+
+        // update and save policy info with instance
+        policyInfo.claimsCount += 1;
+        policyInfo.openClaimsCount += 1;
+        // policy claim amount is only updated when claim is confirmed
+        instance.getInstanceStore().updatePolicyClaims(policyNftId, policyInfo, KEEP_STATE());
+
+        emit LogClaimServiceClaimSubmitted(policyNftId, claimId, claimAmount);
+    }
+
+
+    function confirm(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount confirmedAmount,
+        bytes memory data // claim processing data
+    )
+        external
+        virtual
+    {
+        (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        ) = _verifyCallerWithPolicy(policyNftId);
+
+        // check/update claim info
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
+        claimInfo.claimAmount = confirmedAmount;
+        claimInfo.processData = data;
+        instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, CONFIRMED());
+
+        // update and save policy info with instance
+        policyInfo.claimAmount = policyInfo.claimAmount + confirmedAmount;
+        instance.getInstanceStore().updatePolicyClaims(policyNftId, policyInfo, KEEP_STATE());
+
+        emit LogClaimServiceClaimConfirmed(policyNftId, claimId, confirmedAmount);
+    }
+
+    function decline(
+        NftId policyNftId, 
+        ClaimId claimId,
+        bytes memory data // claim processing data
+    )
+        external
+        virtual
+    {
+        (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        ) = _verifyCallerWithPolicy(policyNftId);
+
+        // check/update claim info
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
+        claimInfo.processData = data;
+        claimInfo.closedAt = TimestampLib.blockTimestamp();
+        instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, DECLINED());
+
+        // update and save policy info with instance
+        policyInfo.openClaimsCount -= 1;
+        instance.getInstanceStore().updatePolicyClaims(policyNftId, policyInfo, KEEP_STATE());
+
+        emit LogClaimServiceClaimDeclined(policyNftId, claimId);
+    }
+
+    function close(
+        NftId policyNftId, 
+        ClaimId claimId
+    )
+        external
+        virtual
+    {
+        (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        ) = _verifyCallerWithPolicy(policyNftId);
+
+        // check/update claim info
+        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.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, CLOSED());
+    }
+
+
+    function createPayout(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        bytes memory data
+    )
+        external
+        returns (PayoutId payoutId)
+    {
+        (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        ) = _verifyCallerWithPolicy(policyNftId);
+
+        IPolicy.ClaimInfo memory claimInfo = instanceReader.getClaimInfo(policyNftId, claimId);
+        StateId claimState = instanceReader.getClaimState(policyNftId, claimId);
+
+        // TODO add checks
+        // claim needs to be open
+        // claim.paidAmount + amount <= claim.claimAmount
+
+        // check/update claim info
+        // create payout info with instance
+        uint8 claimNo = claimInfo.payoutsCount + 1;
+        payoutId = PayoutIdLib.toPayoutId(claimId, claimNo);
+        instance.getInstanceStore().createPayout(
+            policyNftId, 
+            payoutId, 
+            IPolicy.PayoutInfo(
+                payoutId.toClaimId(),
+                amount,
+                data,
+                TimestampLib.zero()));
+
+        // update and save claim info with instance
+        claimInfo.payoutsCount += 1;
+        claimInfo.openPayoutsCount += 1;
+        instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, KEEP_STATE());
+
+        // update and save policy info with instance
+        policyInfo.payoutAmount.add(amount);
+        instance.getInstanceStore().updatePolicyClaims(policyNftId, policyInfo, KEEP_STATE());
+
+        emit LogClaimServicePayoutCreated(policyNftId, payoutId, amount);
+    }
+
+
+    function processPayout(
+        NftId policyNftId, 
+        PayoutId payoutId
+    )
+        external
+        virtual
+    {
+        (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        ) = _verifyCallerWithPolicy(policyNftId);
+
+        // TODO add check that payout exists and is open
+        IPolicy.PayoutInfo memory payoutInfo = instanceReader.getPayoutInfo(policyNftId, payoutId);
+
+        // update and save payout info with instance
+        payoutInfo.paidAt = TimestampLib.blockTimestamp();
+        instance.getInstanceStore().updatePayout(policyNftId, payoutId, payoutInfo, PAID());
+
+        // TODO update and save claim info with instance
+        ClaimId claimId = payoutId.toClaimId();
+        Amount payoutAmount = payoutInfo.amount;
+        IPolicy.ClaimInfo memory claimInfo = instanceReader.getClaimInfo(policyNftId, claimId);
+        claimInfo.paidAmount = claimInfo.paidAmount.add(payoutAmount);
+        claimInfo.openPayoutsCount -= 1;
+
+        // check if this payout is closing the linked claim
+        // update claim and policy info accordingly
+        if(claimInfo.openPayoutsCount == 0 && claimInfo.paidAmount == claimInfo.claimAmount) {
+            claimInfo.closedAt == TimestampLib.blockTimestamp();
+            instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, CLOSED());
+
+            policyInfo.openClaimsCount -= 1;
+        } else {
+            instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, KEEP_STATE());
+        }
+
+        // update and save policy info with instance
+        policyInfo.payoutAmount = policyInfo.payoutAmount.add(payoutAmount);
+        instance.getInstanceStore().updatePolicyClaims(policyNftId, policyInfo, KEEP_STATE());
+
+        // inform pool about payout
+        _poolService.reduceCollateral(
+            instance, 
+            address(instanceReader.getComponentInfo(policyInfo.productNftId).token),
+            policyNftId, 
+            policyInfo, 
+            payoutAmount);
+
+        // transfer payout token and fee
+        (
+            Amount netPayoutAmount,
+            address beneficiary
+        ) = _transferPayoutAmount(
+            instanceReader,
+            policyNftId,
+            policyInfo,
+            payoutInfo);
+
+        // TODO callback IPolicyHolder
+
+        emit LogClaimServicePayoutProcessed(policyNftId, payoutId, payoutAmount, beneficiary, netPayoutAmount);
+    }
+
+    // TODO create (I)TreasuryService that deals with all gif related token transfers
+    function _transferPayoutAmount(
+        InstanceReader instanceReader,
+        NftId policyNftId,
+        IPolicy.PolicyInfo memory policyInfo,
+        IPolicy.PayoutInfo memory payoutInfo
+    )
+        internal
+        returns (
+            Amount netPayoutAmount,
+            address beneficiary
+        )
+    {
+        Amount payoutAmount = payoutInfo.amount;
+
+        if(payoutAmount.gtz()) {
+            NftId productNftId = policyInfo.productNftId;
+
+            // get pool component info from policy or product
+            NftId poolNftId = getRegistry().getObjectInfo(policyInfo.bundleNftId).parentNftId;
+            IComponents.ComponentInfo memory poolInfo = instanceReader.getComponentInfo(poolNftId);
+
+            netPayoutAmount = payoutAmount;
+            beneficiary = _getBeneficiary(policyNftId, payoutInfo.claimId);
+
+            IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
+            if(FeeLib.gtz(productInfo.processingFee)) {
+                // TODO calculate net payout and processing fees
+                // TODO transfer processing fees to product wallet
+                // TODO inform product to update fee book keeping
+            }
+
+            poolInfo.tokenHandler.transfer(
+                poolInfo.wallet,
+                beneficiary,
+                netPayoutAmount);
+        }
+    }
+
+    // internal functions
+
+    function _getBeneficiary(
+        NftId policyNftId,
+        ClaimId claimId
+    )
+        internal
+        returns (address beneficiary)
+    {
+        // TODO check if owner is IPolicyHolder
+        // if so, obtain beneficiary from this contract
+
+        // default beneficiary is policy nft owner
+        beneficiary = getRegistry().ownerOf(policyNftId);
+    }
+
+
+    function _verifyCallerWithPolicy(
+        NftId policyNftId
+    )
+        internal
+        view
+        virtual
+        returns (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        )
+    {
+        NftId productNftId;
+        (productNftId,, instance) = _getAndVerifyActiveComponent(PRODUCT());
+        instanceReader = instance.getInstanceReader();
+
+        // check caller(product) policy match
+        policyInfo = instanceReader.getPolicyInfo(policyNftId);
+        if(policyInfo.productNftId != productNftId) {
+            revert ErrorClaimServicePolicyProductMismatch(policyNftId, 
+            policyInfo.productNftId, 
+            productNftId);
+        }
+    }
+
+    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 _getDomain() internal pure override returns(ObjectType) {
+        return CLAIM();
+    }
+}

package/contracts/product/ClaimServiceManager.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../shared/IVersionable.sol";
+import {ProxyManager} from "../shared/ProxyManager.sol";
+import {ClaimService} from "./ClaimService.sol";
+
+contract ClaimServiceManager is ProxyManager {
+
+    ClaimService private _claimService;
+
+    /// @dev initializes proxy manager with service implementation 
+    constructor(
+        address authority, 
+        address registryAddress,
+        bytes32 salt
+    ) 
+        ProxyManager(registryAddress)
+    {
+        ClaimService svc = new ClaimService{salt: salt}();
+        bytes memory data = abi.encode(registryAddress, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
+            address(svc), 
+            data,
+            salt);
+
+        _claimService = ClaimService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getClaimService()
+        external
+        view
+        returns (ClaimService)
+    {
+        return _claimService;
+    }
+}

package/contracts/{instance/service → product}/IApplicationService.sol

@@ -1,45 +1,45 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {IRisk} from "../module/IRisk.sol";
-import {IService} from "../../shared/IService.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IService} from "../shared/IService.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";
-import {Fee} from "../../types/Fee.sol";
+import {Amount} from "../type/Amount.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";
 
 /// @dev gif service responsible for creating applications
 /// only product components may call transaction functions
 interface IApplicationService is IService {
     
-    error IApplicationServicePolicyNotApplied(NftId applicationNftId);
+    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
     function create(
         address applicationOwner,
         RiskId riskId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
-        uint256 sumInsuredAmount,
-        uint256 lifetime,
         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 ajust(
+    function adjust(
         NftId applicationNftId,
         RiskId riskId,
         NftId bundleNftId,
         ReferralId referralId,
-        uint256 sumInsuredAmount,
-        uint256 lifetime,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
         bytes memory applicationData
     ) external;
 
@@ -59,24 +59,4 @@ interface IApplicationService is IService {
     /// an application can only be revoked in applied state
     /// only the application holder may revoke an application
     function revoke(NftId policyNftId) external;
-
-    /// @dev calculates the premium amount for the specified attributes
-    /// also returns the various fee components involved with creating a policy
-    function calculatePremium(
-        RiskId riskId,
-        uint256 sumInsuredAmount,
-        uint256 lifetime,
-        bytes memory applicationData,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        external
-        view
-        returns (
-            uint256 premiumAmount,
-            uint256 distributionFeeAmount,
-            uint256 productFeeAmount,
-            uint256 poolFeeAmount,
-            uint256 bundleFeeAmount
-        );
-}
+}

package/contracts/product/IClaimService.sol

@@ -0,0 +1,99 @@
+// 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 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);
+
+    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 submit(
+        NftId policyNftId, 
+        Amount claimAmount,
+        bytes memory claimData
+    ) external returns (ClaimId claimId);
+
+
+    // TODO add claim revoke functionality
+
+
+    /// @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 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
+    /// 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;
+}