@etherisc/gif-next 0.0.2-e94f4c7-084 → 0.0.2-e987ccf-894

package/contracts/product/ClaimService.sol

@@ -0,0 +1,416 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+import {ObjectType, CLAIM, PRODUCT, POOL} from "../type/ObjectType.sol";
+import {SUBMITTED, KEEP_STATE, DECLINED, CONFIRMED, CLOSED, PAID} from "../type/StateId.sol";
+import {NftId} from "../type/NftId.sol";
+import {FeeLib} from "../type/Fee.sol";
+import {StateId} from "../type/StateId.sol";
+import {ClaimId, ClaimIdLib} from "../type/ClaimId.sol";
+import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
+import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IClaimService} from "./IClaimService.sol";
+import {IPoolService} from "../pool/IPoolService.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
+        ) = _calculatePayoutAmount(
+            instanceReader,
+            policyNftId,
+            policyInfo,
+            payoutInfo);
+
+        // TODO callback IPolicyHolder
+
+        emit LogClaimServicePayoutProcessed(policyNftId, payoutId, payoutAmount, beneficiary, netPayoutAmount);
+
+        {
+            NftId poolNftId = getRegistry().getObjectInfo(policyInfo.bundleNftId).parentNftId;
+            IComponents.ComponentInfo memory poolInfo = instanceReader.getComponentInfo(poolNftId);
+            poolInfo.tokenHandler.distributeTokens(poolInfo.wallet, beneficiary, netPayoutAmount);
+        }
+    }
+
+    function _calculatePayoutAmount(
+        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
+            }
+        }
+    }
+
+    // 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/{instance/service → product}/ClaimServiceManager.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../../shared/IVersionable.sol";
-import {ProxyManager} from "../../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {ClaimService} from "./ClaimService.sol";
 
 contract ClaimServiceManager is ProxyManager {
@@ -11,15 +11,18 @@ contract ClaimServiceManager is ProxyManager {
 
     /// @dev initializes proxy manager with service implementation 
     constructor(
-        address registryAddress
-    )
+        address authority, 
+        address registryAddress,
+        bytes32 salt
+    ) 
         ProxyManager(registryAddress)
     {
-        ClaimService svc = new ClaimService();
-        bytes memory data = abi.encode(registryAddress, address(this));
-        IVersionable versionable = deploy(
+        ClaimService svc = new ClaimService{salt: salt}();
+        bytes memory data = abi.encode(registryAddress, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
             address(svc), 
-            data);
+            data,
+            salt);
 
         _claimService = ClaimService(address(versionable));
     }

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

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {IPolicy} from "../module/IPolicy.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 {ObjectType} from "../../types/ObjectType.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
-import {Seconds} from "../../types/Seconds.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
@@ -22,7 +23,8 @@ interface IApplicationService is IService {
     function create(
         address applicationOwner,
         RiskId riskId,
-        uint256 sumInsuredAmount,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
@@ -37,8 +39,8 @@ interface IApplicationService is IService {
         RiskId riskId,
         NftId bundleNftId,
         ReferralId referralId,
-        uint256 sumInsuredAmount,
-        uint256 lifetime,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
         bytes memory applicationData
     ) external;
 
@@ -58,21 +60,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(
-        NftId productNftId,
-        RiskId riskId,
-        uint256 sumInsuredAmount,
-        Seconds lifetime,
-        bytes memory applicationData,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        external
-        view
-        returns (
-            IPolicy.Premium memory premium
-        );
-}
+}

package/contracts/product/IClaimService.sol

@@ -0,0 +1,100 @@
+// 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 ErrorClaimsServicePayoutAmountIsZero(NftId policyNftId, PayoutId payoutId);
+
+    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;
+}

package/contracts/product/IPolicyService.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {NftId} from "../type/NftId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IPolicyService is IService {
+
+    error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
+    error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
+    error ErrorPolicyServicePolicyStateNotCollateralized(NftId applicationNftId);
+    error ErrorPolicyServicePolicyAlreadyActivated(NftId policyNftId);
+
+    error ErrorPolicyServiceBalanceInsufficient(address policyOwner, uint256 premiumAmount, uint256 balance);
+    error ErrorPolicyServiceAllowanceInsufficient(address policyOwner, address tokenHandler, uint256 premiumAmount, uint256 allowance);
+
+    error ErrorPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId, Amount premiumPaidAmount);
+    error ErrorPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+    error ErrorPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
+    error ErrorPolicyServicePremiumNotFullyPaid(NftId policyNftId, Amount premiumAmount, Amount premiumPaidAmount);
+    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);
+
+    event LogPolicyServicePolicyDeclined(NftId policyNftId);
+    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);
+
+    /// @dev creates the policy from {applicationNftId}. 
+    /// 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
+    function createPolicy(
+        NftId applicationNftId,
+        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 (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 expires the specified policy and sets the expiry date in the policy metadata. 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;
+
+}