@etherisc/gif-next 0.0.2-7afe9ac-654 → 0.0.2-7b09b39-121

package/contracts/pool/PoolService.sol

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IBundle} from "../instance/module/IBundle.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
@@ -14,7 +17,7 @@ import {IStaking} from "../staking/IStaking.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
+import {NftId} from "../type/NftId.sol";
 import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY} from "../type/ObjectType.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
@@ -65,24 +68,20 @@ contract PoolService is
         registerInterface(type(IPoolService).interfaceId);
     }
 
-
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
+    /// @inheritdoc IPoolService
+    function setMaxBalanceAmount(Amount maxBalanceAmount)
         external
         virtual
     {
-        /*
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
 
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
-        Amount previousMaxCapitalAmount = poolInfo.maxCapitalAmount;
-
-        poolInfo.maxCapitalAmount = maxCapitalAmount;
+        Amount previousMaxBalanceAmount = poolInfo.maxBalanceAmount;
+        poolInfo.maxBalanceAmount = maxBalanceAmount;
         instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
 
-        emit LogPoolServiceMaxCapitalAmountUpdated(poolNftId, previousMaxCapitalAmount, maxCapitalAmount);
-        */
+        emit LogPoolServiceMaxBalanceAmountUpdated(poolNftId, previousMaxBalanceAmount, maxBalanceAmount);
     }
 
     function setBundleOwnerRole(RoleId bundleOwnerRole)
@@ -106,27 +105,7 @@ contract PoolService is
         emit LogPoolServiceBundleOwnerRoleSet(poolNftId, bundleOwnerRole);
     }
 
-
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    )
-        external
-        virtual
-    {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-
-        IComponents.PoolInfo memory poolInfo = instance.getInstanceReader().getPoolInfo(poolNftId);
-        poolInfo.poolFee = poolFee;
-        poolInfo.stakingFee = stakingFee;
-        poolInfo.performanceFee = performanceFee;
-
-        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
-
-        // TODO add logging
-    }
-
+    /// @inheritdoc IPoolService
     function createBundle(
         address bundleOwner, // initial bundle owner
         Fee memory fee, // fees deducted from premium that go to bundle owner
@@ -136,24 +115,32 @@ contract PoolService is
     )
         external 
         virtual
-        returns(NftId bundleNftId)
+        returns(NftId bundleNftId, Amount netStakedAmount)
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
 
-        (
-            Amount stakingFeeAmount,
-            Amount stakingNetAmount
-        ) = FeeLib.calculateFee(
-            _getStakingFee(instanceReader, poolNftId), 
+        {
+            InstanceReader instanceReader = instance.getInstanceReader();
+            IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + stakingAmount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, stakingAmount);
+            }
+        }
+
+
+        Amount stakingFeeAmount;
+        (stakingFeeAmount, netStakedAmount) = FeeLib.calculateFee(
+            _getStakingFee(instance.getInstanceReader(), poolNftId), 
             stakingAmount);
 
+
         bundleNftId = _bundleService.create(
             instance,
             poolNftId,
             bundleOwner,
             fee,
-            stakingNetAmount,
+            netStakedAmount,
             lifetime,
             filter);
 
@@ -161,12 +148,12 @@ contract PoolService is
         _componentService.increasePoolBalance(
             instance.getInstanceStore(), 
             poolNftId, 
-            stakingAmount, 
+            netStakedAmount, 
             stakingFeeAmount);
 
         // pool bookkeeping and collect tokens from bundle owner
         _collectStakingAmount(
-            instanceReader, 
+            instance.getInstanceReader(), 
             poolNftId, 
             bundleOwner, 
             stakingAmount);
@@ -180,8 +167,8 @@ contract PoolService is
         view
         returns (Fee memory stakingFee)
     {
-        NftId productNftId = instanceReader.getPoolInfo(poolNftId).productNftId;
-        return instanceReader.getPoolInfo(productNftId).stakingFee;
+        NftId productNftId = instanceReader.getComponentInfo(poolNftId).productNftId;
+        return instanceReader.getProductInfo(productNftId).stakingFee;
     }
 
     function closeBundle(NftId bundleNftId)
@@ -190,16 +177,147 @@ contract PoolService is
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
-        // TODO book keeping for pool collateral released outside of retention level
+        // TODO get performance fee for pool (#477)
 
         // releasing collateral in bundle
-        _bundleService.close(instance, bundleNftId);
-
-        // TODO get performance fee for pool, transfer of remaining funds + bundle fees to bundle owner
+        (Amount unstakedAmount, Amount feeAmount) = _bundleService.close(instance, bundleNftId);
 
+        _componentService.decreasePoolBalance(
+            instance.getInstanceStore(), 
+            poolNftId, 
+            unstakedAmount +  feeAmount, 
+            AmountLib.zero());
+        
         emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId);
+
+        if ((unstakedAmount + feeAmount).gtz()){
+            IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolNftId);
+            TokenHandler tokenHandler = poolComponentInfo.tokenHandler;
+            IERC20Metadata token = IERC20Metadata(poolComponentInfo.token);
+
+            // TODO: centralize token handling (issue #471)
+            
+            // check allowance
+            uint256 tokenAllowance = token.allowance(poolComponentInfo.wallet, address(tokenHandler));
+            if (tokenAllowance < (unstakedAmount.toInt() +  feeAmount.toInt())) {
+                revert ErrorPoolServiceWalletAllowanceTooSmall(
+                    poolComponentInfo.wallet, 
+                    address(tokenHandler), 
+                    tokenAllowance, 
+                    unstakedAmount.toInt() + feeAmount.toInt());
+            }
+
+            // transfer amount to bundle owner
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            tokenHandler.transfer(poolComponentInfo.wallet, bundleOwner, unstakedAmount + feeAmount);
+        }
+    }
+
+    /// @inheritdoc IPoolService
+    function stake(NftId bundleNftId, Amount amount) 
+        external 
+        virtual
+        // TODO: restricted() (once #462 is done)
+        returns(Amount netAmount) 
+    {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+        if (bundleInfo.poolNftId != poolNftId) {
+            revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+
+        {
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + amount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, amount);
+            }
+        }
+
+        // calculate fees
+        Amount feeAmount;
+        (
+            feeAmount,
+            netAmount
+        ) = FeeLib.calculateFee(
+            _getStakingFee(instanceReader, poolNftId), 
+            amount);
+
+        // do all the bookkeeping
+        _componentService.increasePoolBalance(
+            instance.getInstanceStore(), 
+            poolNftId, 
+            netAmount, 
+            feeAmount);
+
+        _bundleService.stake(instance, bundleNftId, netAmount);
+
+        // collect tokens from bundle owner
+        address bundleOwner = getRegistry().ownerOf(bundleNftId);
+        emit LogPoolServiceBundleStaked(instance.getNftId(), poolNftId, bundleNftId, amount, netAmount);
+        _collectStakingAmount(
+            instanceReader, 
+            poolNftId, 
+            bundleOwner, 
+            amount);
     }
 
+    /// @inheritdoc IPoolService
+    function unstake(NftId bundleNftId, Amount amount) 
+        external 
+        virtual
+        // TODO: restricted() (once #462 is done)
+        returns(Amount netAmount) 
+    {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        InstanceStore instanceStore = instance.getInstanceStore();
+        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+        
+        if (bundleInfo.poolNftId != poolNftId) {
+            revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+
+        if (amount.eqz()) {
+            revert ErrorPoolServiceAmountIsZero();
+        }
+
+        // call bundle service for bookkeeping and additional checks
+        Amount unstakedAmount = _bundleService.unstake(instance, bundleNftId, amount);
+
+        // Important: from now on work only with unstakedAmount as it is the only reliable amount.
+        // if amount was max, this was set to the available amount
+
+        // TODO: handle performance fees (issue #477)
+
+        // update pool bookkeeping - performance fees stay in the pool, but as fees 
+        _componentService.decreasePoolBalance(
+            instanceStore, 
+            poolNftId, 
+            unstakedAmount, 
+            AmountLib.zero());
+
+        IComponents.ComponentInfo memory poolComponentInfo = instanceReader.getComponentInfo(poolNftId);
+        address poolWallet = poolComponentInfo.wallet;
+
+        // check allowance
+        {
+            IERC20Metadata token = IERC20Metadata(poolComponentInfo.token);
+            uint256 tokenAllowance = token.allowance(poolWallet, address(poolComponentInfo.tokenHandler));
+            if (tokenAllowance < unstakedAmount.toInt()) {
+                revert ErrorPoolServiceWalletAllowanceTooSmall(poolWallet, address(poolComponentInfo.tokenHandler), tokenAllowance, amount.toInt());
+            }
+        }
+
+        // transfer amount to bundle owner
+        address owner = getRegistry().ownerOf(bundleNftId);
+        emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount);
+        // TODO: centralize token handling (issue #471)
+        poolComponentInfo.tokenHandler.transfer(poolWallet, owner, unstakedAmount);
+        return unstakedAmount;
+    }
 
     function processSale(
         NftId bundleNftId, 
@@ -420,10 +538,18 @@ contract PoolService is
         address poolWallet = componentInfo.wallet;
 
         if(amount.gtz()) {
+            uint256 allowance = IERC20Metadata(componentInfo.token).allowance(bundleOwner, address(tokenHandler));
+            if (allowance < amount.toInt()) {
+                revert ErrorPoolServiceWalletAllowanceTooSmall(bundleOwner, address(tokenHandler), allowance, amount.toInt());
+            }
+
+            // TODO: centralize token handling (issue #471)
             tokenHandler.transfer(
                 bundleOwner,
                 poolWallet,
                 amount);
+        } else {
+            revert ErrorPoolServiceAmountIsZero();
         }
     }
 

package/contracts/product/ApplicationService.sol

@@ -128,6 +128,7 @@ contract ApplicationService is
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
@@ -152,13 +153,45 @@ contract ApplicationService is
         applicationNftId = _registerApplication(productNftId, applicationOwner);
 
         // create policy info for application
-        IPolicy.PolicyInfo memory applicationInfo = IPolicy.PolicyInfo({
+        IPolicy.PolicyInfo memory applicationInfo = _createApplicationInfo(
+            productNftId,
+            riskId,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId,
+            referralId,
+            applicationData);
+
+        // register application with instance
+        instance.getInstanceStore().createApplication(
+            applicationNftId, 
+            applicationInfo);
+
+        // TODO: add logging
+    }
+
+    function _createApplicationInfo(
+        NftId productNftId,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime,
+        NftId bundleNftId,
+        ReferralId referralId,
+        bytes memory applicationData
+    )
+        internal
+        virtual
+        returns (IPolicy.PolicyInfo memory applicationInfo)
+    {
+        return IPolicy.PolicyInfo({
             productNftId:       productNftId,
             bundleNftId:        bundleNftId,
             referralId:         referralId,
             riskId:             riskId,
             sumInsuredAmount:   sumInsuredAmount,
-            premiumAmount:      AmountLib.zero(),
+            premiumAmount:      premiumAmount,
             premiumPaidAmount:  AmountLib.zero(),
             lifetime:           lifetime,
             applicationData:    applicationData,
@@ -171,21 +204,8 @@ contract ApplicationService is
             expiredAt:          zeroTimestamp(),
             closedAt:           zeroTimestamp()
         });
-
-        // TODO consider to provide this amount externally
-        // actual calculation is done 2nd time anyway for premium collection
-        // calculate premium amount
-        applicationInfo.premiumAmount = _calculatePremiumAmount(applicationInfo);
-
-        // register application with instance
-        instance.getInstanceStore().createApplication(
-            applicationNftId, 
-            applicationInfo);
-
-        // TODO: add logging
     }
 
-
     function renew(
         NftId policyNftId, // policy to be renewd (renewal inherits policy attributes)
         NftId bundleNftId // will likely need a newer bundle for underwriting

package/contracts/product/BasicProduct.sol

@@ -1,43 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
-import {Amount, AmountLib} from "../type/Amount.sol";
-import {ClaimId} from "../type/ClaimId.sol";
-import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
-import {IRisk} from "../instance/module/IRisk.sol";
-import {IApplicationService} from "./IApplicationService.sol";
+import {Fee} from "../type/Fee.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
-import {IComponentService} from "../shared/IComponentService.sol";
-import {IPolicyService} from "./IPolicyService.sol";
-import {IProductService} from "./IProductService.sol";
-import {IClaimService} from "./IClaimService.sol";
-import {IPricingService} from "./IPricingService.sol";
-import {IProductComponent} from "./IProductComponent.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
+import {NftId} from "../type/NftId.sol";
 import {Product} from "../product/Product.sol";
-import {PayoutId} from "../type/PayoutId.sol";
-import {COMPONENT, PRODUCT, APPLICATION, POLICY, CLAIM, PRICE } from "../type/ObjectType.sol";
-import {ReferralId} from "../type/Referral.sol";
-import {RiskId, RiskIdLib} from "../type/RiskId.sol";
-import {Seconds} from "../type/Seconds.sol";
-import {StateId} from "../type/StateId.sol";
-import {Timestamp} from "../type/Timestamp.sol";
-
-import {TokenHandler} from "../shared/TokenHandler.sol";
-
-import {InstanceReader} from "../instance/InstanceReader.sol";
-import {IPolicy} from "../instance/module/IPolicy.sol";
-import {IComponents} from "../instance/module/IComponents.sol";
-import {Pool} from "../pool/Pool.sol";
-import {Distribution} from "../distribution/Distribution.sol";
 
 abstract contract BasicProduct is
     Product
 {
- 
+
     function setFees(
         Fee memory productFee,
         Fee memory processingFee
@@ -49,8 +21,6 @@ abstract contract BasicProduct is
     {
         _setFees(productFee, processingFee);
     }
-
-
     function _initializeBasicProduct(
         address registry,
         NftId instanceNftId,

package/contracts/product/ClaimService.sol

@@ -294,7 +294,7 @@ contract ClaimService is
         (
             Amount netPayoutAmount,
             address beneficiary
-        ) = _transferPayoutAmount(
+        ) = _calculatePayoutAmount(
             instanceReader,
             policyNftId,
             policyInfo,
@@ -302,11 +302,24 @@ contract ClaimService is
 
         // TODO callback IPolicyHolder
 
+        if (netPayoutAmount.eqz()) {
+            revert ErrorClaimsServicePayoutAmountIsZero(policyNftId, payoutId);
+        }
+
         emit LogClaimServicePayoutProcessed(policyNftId, payoutId, payoutAmount, beneficiary, netPayoutAmount);
+
+        {
+            NftId poolNftId = getRegistry().getObjectInfo(policyInfo.bundleNftId).parentNftId;
+            IComponents.ComponentInfo memory poolInfo = instanceReader.getComponentInfo(poolNftId);
+            // TODO: centralize token handling (issue #471)
+            poolInfo.tokenHandler.transfer(
+                poolInfo.wallet,
+                beneficiary,
+                netPayoutAmount);
+        }
     }
 
-    // TODO create (I)TreasuryService that deals with all gif related token transfers
-    function _transferPayoutAmount(
+    function _calculatePayoutAmount(
         InstanceReader instanceReader,
         NftId policyNftId,
         IPolicy.PolicyInfo memory policyInfo,
@@ -336,11 +349,6 @@ contract ClaimService is
                 // TODO transfer processing fees to product wallet
                 // TODO inform product to update fee book keeping
             }
-
-            poolInfo.tokenHandler.transfer(
-                poolInfo.wallet,
-                beneficiary,
-                netPayoutAmount);
         }
     }
 

package/contracts/product/IApplicationService.sol

@@ -24,6 +24,7 @@ interface IApplicationService is IService {
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,

package/contracts/product/IClaimService.sol

@@ -31,6 +31,7 @@ interface IClaimService is
     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);

package/contracts/product/IPolicyService.sol

@@ -20,25 +20,31 @@ interface IPolicyService is IService {
 
     error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
     error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
-    error ErrorPolicyServicePolicyStateNotCollateralizedOrApplied(NftId applicationNftId);
+    error ErrorPolicyServicePolicyStateNotCollateralized(NftId applicationNftId);
+    error ErrorPolicyServicePolicyAlreadyActivated(NftId policyNftId);
 
-    error ErrorPolicyServicePremiumHigherThanExpected(Amount premiumExpectedAmount, Amount premiumToBePaidAmount);
+    error ErrorPolicyServicePremiumHigherThanExpected(uint256 premiumExpectedAmount, uint256 premiumToBePaidAmount);
     error ErrorPolicyServiceBalanceInsufficient(address policyOwner, uint256 premiumAmount, uint256 balance);
     error ErrorPolicyServiceAllowanceInsufficient(address policyOwner, address tokenHandler, uint256 premiumAmount, uint256 allowance);
 
-    error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
     error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId, Amount premiumPaidAmount);
-    error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
-    error ErrorIPolicyServicePolicyAlreadyClosed(NftId policyNftId);
-    error ErrorIPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
+    error ErrorPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+    error ErrorPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
     error ErrorPolicyServicePremiumNotFullyPaid(NftId policyNftId, Amount premiumAmount, Amount premiumPaidAmount);
-    error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
-    error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
+    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);
 
-    /// @dev collateralizes the policy represented by {policyNftId}
+    event LogPolicyServicePolicyDeclined(NftId policyNftId);
+    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);
+
+    /// @dev collateralizes the policy represented by {policyNftId}. locks the sum insured amount in the pool.
     /// 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.
@@ -57,18 +63,19 @@ interface IPolicyService is IService {
     /// only the related product may decline an application
     function decline(NftId policyNftId) external;
 
-    /// @dev collects the premium token for the specified policy
+    /// @dev collects the premium token for the specified policy (must be in COLLATERALIZED or ACTIVE 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
+    /// @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
-    function expire(NftId policyNftId) external;
+    /// @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