@etherisc/gif-next 0.0.2-eadf4ad-932 → 0.0.2-eae5e95-691

package/contracts/pool/IBundleService.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
 import {NftId} from "../type/NftId.sol";
@@ -26,6 +26,15 @@ interface IBundleService is IService {
 
     error ErrorBundleServicePolicyNotCloseable(NftId policyNftId);
 
+    error ErrorBundleServiceFeesWithdrawAmountExceedsLimit(Amount amount, Amount limit);
+    
+    error ErrorBundleServiceUnstakeAmountExceedsLimit(Amount amount, Amount limit);
+
+    error ErrorBundleServiceExtensionLifetimeIsZero();
+
+    event LogBundleServiceFeesWithdrawn(NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
+    event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
+
     /// @dev create a new bundle for the specified attributes
     /// may only be called by pool service
     function create(
@@ -41,11 +50,20 @@ interface IBundleService is IService {
         returns(NftId bundleNftId); // the nft id of the newly created bundle
 
 
-    /// @dev increase bundle stakes by the specified amount
-    /// may only be called by the bundle owner
-    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    /// @dev increase bundle stakes by the specified amount. bundle must not be expired or closed
+    /// may only be called by the pool service
+    function stake(IInstance instance, NftId bundleNftId, Amount amount) external;
 
-    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    /// @dev decrease bundle stakes by the specified amount
+    /// may only be called by the pool service
+    /// @param instance the instance relevant for the bundle
+    /// @param bundleNftId the bundle nft id
+    /// @param amount the amount to unstake (set to AmountLib.max() to unstake all available stakes)
+    /// @return unstakedAmount the effective unstaked amount
+    function unstake(IInstance instance, NftId bundleNftId, Amount amount) external returns (Amount unstakedAmount);
+
+    /// @dev extend the lifetime of the bundle by the specified time in seconds
+    function extend(NftId bundleNftId, Seconds lifetimeExtension) external returns (Timestamp extendedExpiredAt);
 
     /// @dev locks the specified bundle, locked bundles are not available to collateralize new policies
     /// only active bundles may be locked
@@ -61,10 +79,12 @@ interface IBundleService is IService {
     /// only open bundles (active or locked) may be closed
     /// to close a bundle it may not have any non-closed polices attached to it
     /// may only be called by registered and unlocked pool components
+    /// @return balanceAmount the unstaked amount that was remaining in the bundle
+    /// @return feeAmount the fee amount that was remaining for the bundle
     function close(
         IInstance instance, 
         NftId bundleNftId
-    ) external;
+    ) external returns (Amount balanceAmount, Amount feeAmount);
 
     /// @dev set bundle fee to provided value
     /// may only be called by registered and unlocked pool components
@@ -80,13 +100,13 @@ interface IBundleService is IService {
     /// the premium (minus bundle fee) is added to the bundle capital
     /// may only be called by pool service
     function lockCollateral(
-        IInstance instanceNftId, 
+        IInstance instance, 
         NftId policyNftId, 
         NftId bundleNftId, 
-        Amount collateralAmount, 
-        Amount premiumAmount // premium after pool fee
+        Amount collateralAmount
     ) external;
 
+
     /// @dev releases the specified collateral in the bundle
     /// may only be called by pool service
     function releaseCollateral(
@@ -104,15 +124,20 @@ interface IBundleService is IService {
         NftId policyNftId
     ) external;
 
-    /// @dev updates the bundle's fees of with the provided fee amount
-    function updateBundleFees(
-        IInstance instance,
-        NftId bundleNftId,
-        Amount feeAmount
-    ) external;
+    // FIXME: move to pool service
+    /// @dev Withdraw bundle feeds for the given bundle
+    /// @param bundleNftId the bundle Nft Id
+    /// @param amount the amount to withdraw. If set to AMOUNT_MAX, the full commission available is withdrawn
+    /// @return withdrawnAmount the effective withdrawn amount
+    function withdrawBundleFees(NftId bundleNftId, Amount amount) external returns (Amount withdrawnAmount);
+
+    /// @dev returns true iff policy may be closed
+    /// a policy can be closed all conditions below are met
+    /// - policy exists
+    /// - has been activated
+    /// - is not yet closed
+    /// - has no open claims
+    /// - claim amount matches sum insured amount or is expired
+    function policyIsCloseable(IInstance instance, NftId policyNftId) external view returns (bool isCloseable);
 
-    function increaseBalance(
-        IInstance instance, 
-        NftId bundleNftId,  
-        Amount amount) external;
 }

package/contracts/pool/IPoolComponent.sol

@@ -2,8 +2,9 @@
 pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {Fee} from "../type/Fee.sol";
-import {IComponent} from "../shared/IComponent.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {NftId} from "../type/NftId.sol";
 import {RoleId} from "../type/RoleId.sol";
@@ -12,78 +13,18 @@ import {UFixed} from "../type/UFixed.sol";
 
 /// @dev pool components hold and manage the collateral to cover active policies
 /// pools come in different flavors
-interface IPoolComponent is IComponent {
+interface IPoolComponent is IInstanceLinkedComponent {
 
     error ErrorPoolNotBundleOwner(NftId bundleNftId, address caller);
     error ErrorPoolNotPoolService(address caller);
-
     error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
 
     event LogPoolVerifiedByPool(address pool, NftId applicationNftId, Amount collateralizationAmount);
 
-    /// @dev increases the staked tokens by the specified amount
-    /// only the bundle owner may stake tokens
-    /// bundle MUST be in active or locked state
-    function stake(NftId bundleNftId, Amount amount) external;
-
-    /// @dev decreases the staked tokens by the specified amount
-    /// only the bundle owner may unstake tokens from the bundle
-    /// bundle MUST be in active, locked or closed state
-    function unstake(NftId bundleNftId, Amount amount) external;
-
-    /// @dev extends the bundle lifetime of the bundle by the specified time
-    /// only the bundle owner may extend the bundle's lifetime
-    /// bundle MUST be in active or locked state
-    function extend(NftId bundleNftId, Seconds lifetimeExtension) external;
-
-    /// @dev locks the specified bundle
-    /// a bundle to be locked MUST be in active state
-    /// locked bundles may not be used to collateralize any new policy
-    function lockBundle(NftId bundleNftId) external;
-
-    /// @dev unlocks the specified bundle
-    /// a bundle to be unlocked MUST be in locked state
-    function unlockBundle(NftId bundleNftId) external;
-
-    /// @dev close the specified bundle
-    /// a bundle to be closed MUST be in active or locked state
-    /// to close a bundle all all linked policies MUST be in closed state as well
-    /// closing a bundle finalizes the bundle bookkeeping including overall profit calculation
-    /// once a bundle is closed this action cannot be reversed
-    function close(NftId bundleNftId) external;
-
-    /// @dev sets the fee for the specified bundle
-    /// the fee is added on top of the poolFee and deducted from the premium amounts
-    /// via these fees individual bundler owner may earn income per policy in the context of peer to peer pools
-    function setBundleFee(
-        NftId bundleNftId, 
-        Fee memory fee
-    ) external;
-
-    /// @dev sets the maximum overall capital amound held by this pool
-    /// function may only be called by pool owner
-    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
-
-    /// @dev sets the required role to create/own bundles
-    /// may only be called once after setting up a pool
-    /// may only be called by pool owner 
-    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
-
-    /// @dev update pool fees to the specified values
-    /// pool fees: are deducted from the premium amount and goes to the pool owner
-    /// staking fees: are deducted from the staked tokens by a bundle owner and goes to the pool owner
-    /// performance fees: when a bundle is closed a bundle specific profit is calculated
-    /// the performance fee is deducted from this profit and goes to the pool owner
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    ) external;
-
-    /// @dev this is a callback function that is called by the product service when underwriting a policy.
-    /// the pool has the option to check the details and object to underwriting by reverting.
-    /// the function is only called for "active" pools that ask to be involved/notified
-    /// by product related state changes.
+    /// @dev This is a callback function that is called by the product service when underwriting a policy.
+    /// The pool has the option to check the details and object to underwriting by reverting.
+    /// The function is only called for "active" pools that ask to be involved/notified.
+    /// The default implementation is empty.
     function verifyApplication(
         NftId applicationNftId, 
         bytes memory applicationData,
@@ -92,9 +33,9 @@ interface IPoolComponent is IComponent {
         Amount collateralizationAmount
     ) external;
 
-    /// @dev returns true iff the application matches with the bundle 
-    /// this is a callback function that is only called if a pool declares itself as a verifying pool
-    /// default implementation returns true
+    /// @dev Returns true iff the application matches with the bundle.
+    /// This is a callback function that is only called if a pool declares itself as a verifying pool
+    /// The default implementation returns true.
     function applicationMatchesBundle(
         NftId applicationNftId, 
         bytes memory applicationData,
@@ -106,9 +47,22 @@ interface IPoolComponent is IComponent {
         view
         returns (bool isMatching);
 
-    /// @dev returns pool specific infos for this pool
-    /// when registered with an instance the info is obtained from the data stored in the instance
-    /// when not registered the function returns the info from the component contract
-    function getPoolInfo() external view returns (IComponents.PoolInfo memory info);
+    /// @dev This is a callback function that is called by the claim service when a claim is confirmed.
+    /// The pool has the option to implement custom behavirous such as triggering a reinsurance claim or blocking the claim confirmaation.
+    /// The default implementation is empty.
+    function processConfirmedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount amount
+    ) external;
+
+    /// @dev Withdraw bundle feeds for the given bundle
+    /// @param bundleNftId the bundle Nft Id
+    /// @param amount the amount to withdraw. If set to AMOUNT_MAX, the full commission available is withdrawn
+    /// @return withdrawnAmount the effective withdrawn amount
+    function withdrawBundleFees(NftId bundleNftId, Amount amount) external returns (Amount withdrawnAmount);
+
+    /// @dev Returns initial pool specific infos for this pool
+    function getInitialPoolInfo() external view returns (IComponents.PoolInfo memory info);
 
 }

package/contracts/pool/IPoolService.sol

@@ -1,47 +1,42 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {Fee} from "../type/Fee.sol";
-import {NftId} from "../type/NftId.sol";
-import {PayoutId} from "../type/PayoutId.sol";
 import {IBundle} from "../instance/module/IBundle.sol";
 import {IInstance} from "../instance/IInstance.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
 import {IService} from "../shared/IService.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
 import {RoleId} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {StateId} from "../type/StateId.sol";
+import {UFixed} from "../type/UFixed.sol";
 
 interface IPoolService is IService {
 
-    event LogPoolServiceMaxCapitalAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
+    event LogPoolServiceMaxBalanceAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
     event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
 
     event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
     event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
 
-    error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
-    error ErrorPoolServiceBundlePoolMismatch(NftId bundlePoolNftId, NftId productPoolNftId);
-    error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
-
-    /// @dev registers a new pool with the registry service
-    function register(address poolAddress) external returns(NftId);
-
-    /// @dev defines the required role for bundle owners for the calling pool
-    /// default implementation returns PUBLIC ROLE
-    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
+    event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount);
 
-    /// @dev sets the max capital amount for the calling pool
-    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
+    event LogPoolServiceProcessFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount);
 
-    /// @dev set pool sepecific fees
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    ) external;
+    error ErrorPoolServicePolicyPoolMismatch(NftId policyNftId, NftId productNftId, NftId expectedProductNftId);
+    error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
+    error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
+    error ErrorPoolServiceBundlePoolMismatch(NftId bundleNftId, NftId poolNftId);
+    error ErrorPoolServiceMaxBalanceAmountExceeded(NftId poolNftId, Amount maxBalanceAmount, Amount currentBalanceAmount, Amount transferAmount);
 
+    /// @dev sets the max balance amount for the calling pool
+    function setMaxBalanceAmount(Amount maxBalanceAmount) external;
 
     /// @dev locks required collateral to cover the specified application (and turn it into a policy)
     /// - retention level == 1: the full collateral amount will be locked by the specified bundle
@@ -50,40 +45,46 @@ interface IPoolService is IService {
     /// may only be called by the policy service for unlocked pool components
     function lockCollateral(
         IInstance instance, 
+        address token,
         NftId productNftId,
         NftId applicationNftId,
-        IPolicy.PolicyInfo memory applicationInfo,
-        Amount premiumAmount
-    ) external;
+        NftId bundleNftId,
+        Amount sumInsuredAmount // premium amount after product and distribution fees
+    )
+        external
+        returns (
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        );
 
 
     /// @dev releases the remaining collateral linked to the specified policy
     /// may only be called by the policy service for unlocked pool components
     function releaseCollateral(
         IInstance instance, 
+        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo
     ) external;
 
 
-    /// @dev reduces the locked collateral in the bundle associated with the specified policy
+    /// @dev reduces the locked collateral in the bundle associated with the specified policy and updates pool/bundle counters
     /// every payout of a policy reduces the collateral by the payout amount
     /// may only be called by the claim service for unlocked pool components
-    function reduceCollateral(
+    function processPayout(
         IInstance instance, 
+        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo,
         Amount payoutAmount
     ) external;
 
 
-    /// @dev create a new bundle for the provided parameters
-    /// staking fees will be deducted by the pool service from the staking amount
-    /// may only be called by registered and unlocked pool components
+    /// @dev create a new empty bundle with the provided parameters
+    /// may only be called by registered and unlocked pool components.
     function createBundle(
         address owner, // initial bundle owner
         Fee memory fee, // fees deducted from premium that go to bundle owner
-        Amount stakingAmount, // staking amount - staking fees result in initial bundle capital
         Seconds lifetime, // initial duration for which new policies are covered
         bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
     )
@@ -91,6 +92,18 @@ interface IPoolService is IService {
         returns(NftId bundleNftId); // the nft id of the newly created bundle
 
 
+    /// @dev increase stakes for bundle
+    /// staking fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
+    function stake(NftId bundleNftId, Amount amount) external returns(Amount netAmount);
+
+
+    /// @dev decrease stakes for bundle
+    /// performance fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
+    function unstake(NftId bundleNftId, Amount amount) external returns(Amount netAmount);
+
+
     /// @dev closes the specified bundle
     /// only open bundles (active or locked) may be closed
     /// to close a bundle it may not have any non-closed polices attached to it
@@ -98,17 +111,57 @@ interface IPoolService is IService {
     /// may only be called by registered and unlocked pool components
     function closeBundle(NftId bundleNftId) external;
 
+
+    /// @dev Informs product about available funds to process a confirmed claim.
+    /// The function triggers a callback to the product component when the product's property isProcessingFundedClaims is set.
+    function processFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount) external;
+
+
+    /// @dev Fund the specified pool wallet with the provided amount.
+    /// This function will collect the amount from the sender address and transfers it to the pool wallet.
+    /// The function will not update balance amounts managed by the framework.
+    /// Only available for externally managed pools.
+    function fundPoolWallet(NftId poolNftId, Amount amount) external;
+
+
+    /// @dev Defund the specified pool wallet with the provided amount.
+    /// This function will transfer the amount from the pool wallet to the sender address.
+    /// The function will not update balance amounts managed by the framework.
+    /// Only available for externally managed pools.
+    function defundPoolWallet(NftId poolNftId, Amount amount) external;
+
+
     /// @dev processes the sale of a bundle and track the pool fee and bundle fee amounts
-    function processSale(NftId bundleNftId, IPolicy.Premium memory premium, Amount actualAmountTransferred) external;
+    function processSale(NftId bundleNftId, IPolicy.PremiumInfo memory premium) external;
 
-    /// @dev increase stakes for bundle
-    /// staking fees will be deducted by the pool service from the staking amount
-    /// may only be called by registered and unlocked pool components
-    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 
+    /// @dev Calulate required collateral for the provided parameters.
+    function calculateRequiredCollateral(
+        InstanceReader instanceReader,
+        NftId productNftId, 
+        Amount sumInsuredAmount
+    )
+        external
+        view 
+        returns(
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
+        );
+
+
+    /// @dev calulate required collateral for the provided parameters.
+    /// Collateralization is applied to sum insured.
+    /// Retention level defines the fraction of the collateral that is required locally.
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        UFixed retentionLevel, 
+        Amount sumInsuredAmount
+    )
+        external
+        pure 
+        returns(
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
+        );
 
-    /// @dev decrease stakes for bundle
-    /// performance fees will be deducted by the pool service from the staking amount
-    /// may only be called by registered and unlocked pool components
-    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 }