@etherisc/gif-next 0.0.2-8773a53-517 → 0.0.2-88095ce-205

package/contracts/pool/IPoolService.sol

@@ -2,14 +2,15 @@
 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";
@@ -17,7 +18,7 @@ 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);
@@ -26,19 +27,20 @@ interface IPoolService is IService {
     event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
     event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount);
 
+    event LogPoolServiceProcessFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount);
+
+    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 ErrorPoolServiceMaxCapitalAmountExceeded(NftId poolNftId, Amount maxCapitalAmount, Amount capitalAmount, Amount amountToBeAdded);
-    error ErrorPoolServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
-    error ErrorPoolServiceAmountIsZero();
-
+    error ErrorPoolServiceMaxBalanceAmountExceeded(NftId poolNftId, Amount maxBalanceAmount, Amount currentBalanceAmount, Amount transferAmount);
+    
     /// @dev defines the required role for bundle owners for the calling pool
     /// default implementation returns PUBLIC ROLE
     function setBundleOwnerRole(RoleId bundleOwnerRole) external;
 
-    /// @dev sets the max capital amount for the calling pool
-    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
+    /// @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
@@ -70,10 +72,10 @@ interface IPoolService is IService {
     ) 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, 
@@ -82,19 +84,28 @@ interface IPoolService is IService {
     ) external;
 
 
-    /// @dev create a new bundle for the provided parameters
-    /// staking fees will be deducted by the pool service from the staking amount
+    /// @dev create a new empty bundle with the provided parameters
     /// may only be called by registered and unlocked pool components.
-    /// The pool balance is equal to the pool fees plus the capital of all bundles. 
     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
     )
         external 
-        returns(NftId bundleNftId, Amount netStakedAmount); // the nft id of the newly created bundle
+        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
@@ -105,21 +116,30 @@ interface IPoolService is IService {
     function closeBundle(NftId bundleNftId) 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) 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 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 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 calulate required collateral for the provided parameters
+    /// @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.PremiumInfo memory premium) external;
+
+
+    /// @dev Calulate required collateral for the provided parameters.
     function calculateRequiredCollateral(
         InstanceReader instanceReader,
         NftId productNftId, 
@@ -128,12 +148,14 @@ interface IPoolService is IService {
         external
         view 
         returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         );
 
 
-    /// @dev calulate required collateral for the provided parameters
+    /// @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, 
@@ -142,8 +164,8 @@ interface IPoolService is IService {
         external
         pure 
         returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         );
 
 }

package/contracts/pool/Pool.sol

@@ -2,7 +2,8 @@
 pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "../type/Amount.sol";
-import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.sol";
+import {BUNDLE, COMPONENT, POLICY, POOL} from "../type/ObjectType.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
@@ -10,13 +11,12 @@ import {IPoolService} from "./IPoolService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
+import {Fee} from "../type/Fee.sol";
+import {NftId} from "../type/NftId.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {Timestamp} from "../type/Timestamp.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
-import {UFixed, UFixedLib} from "../type/UFixed.sol";
+import {UFixedLib} from "../type/UFixed.sol";
 
 abstract contract Pool is
     InstanceLinkedComponent, 
@@ -40,6 +40,16 @@ abstract contract Pool is
     }
 
 
+    function register()
+        external
+        virtual
+        onlyOwner()
+    {
+        _getPoolStorage()._componentService.registerPool();
+        _approveTokenHandler(type(uint256).max);
+    }
+
+
     /// @dev see {IPoolComponent.verifyApplication}
     function verifyApplication(
         NftId applicationNftId, 
@@ -51,6 +61,7 @@ abstract contract Pool is
         public
         virtual
         restricted()
+        onlyNftObjectType(applicationNftId, POLICY())
     {
         if(!applicationMatchesBundle(
             applicationNftId,
@@ -67,6 +78,21 @@ abstract contract Pool is
     }
 
 
+    /// @dev see {IPoolComponent.processConfirmedClaim}
+    function processConfirmedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+        onlyNftObjectType(policyNftId, POLICY())
+    {
+        // default implementation is empty
+    }
+
+
     /// @dev see {IPoolComponent.applicationMatchesBundle}
     /// Override this function to implement any custom application verification 
     /// Default implementation always returns true
@@ -80,27 +106,20 @@ abstract contract Pool is
         public
         virtual
         view
+        onlyNftObjectType(applicationNftId, POLICY())
+        onlyNftObjectType(bundleNftId, BUNDLE())
         returns (bool isMatching)
     {
         return true;
     }
 
-
-    function register()
-        external
-        virtual
-        onlyOwner()
-    {
-        _getPoolStorage()._componentService.registerPool();
-        _approveTokenHandler(type(uint256).max);
-    }
-
     /// @inheritdoc IPoolComponent
     function withdrawBundleFees(NftId bundleNftId, Amount amount) 
         external 
         virtual
         restricted()
         onlyBundleOwner(bundleNftId)
+        onlyNftObjectType(bundleNftId, BUNDLE())
         returns (Amount withdrawnAmount) 
     {
         return _withdrawBundleFees(bundleNftId, amount);
@@ -113,15 +132,16 @@ abstract contract Pool is
         view 
         returns (IComponents.PoolInfo memory poolInfo)
     {
-        return IComponents.PoolInfo(
-            PUBLIC_ROLE(), // bundleOwnerRole
-            AmountLib.max(), // maxCapitalAmount,
-            isNftInterceptor(), // isInterceptingBundleTransfers
-            false, // isExternallyManaged,
-            false, // isVerifyingApplications,
-            UFixedLib.toUFixed(1), // collateralizationLevel,
-            UFixedLib.toUFixed(1) // retentionLevel,
-        );
+        return IComponents.PoolInfo({
+            maxBalanceAmount: AmountLib.max(),
+            bundleOwnerRole: PUBLIC_ROLE(), 
+            isInterceptingBundleTransfers: isNftInterceptor(),
+            isProcessingConfirmedClaims: false,
+            isExternallyManaged: false,
+            isVerifyingApplications: false,
+            collateralizationLevel: UFixedLib.toUFixed(1),
+            retentionLevel: UFixedLib.toUFixed(1)
+        });
     }
 
     // Internals
@@ -158,7 +178,7 @@ abstract contract Pool is
         $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
 
-        registerInterface(type(IPoolComponent).interfaceId);
+        _registerInterface(type(IPoolComponent).interfaceId);
     }
 
     /// @dev increases the staked tokens by the specified amount
@@ -169,9 +189,9 @@ abstract contract Pool is
     )
         internal
         virtual
-        returns(Amount netAmount) 
+        returns(Amount) 
     {
-        _getPoolStorage()._poolService.stake(bundleNftId, amount);
+        return _getPoolStorage()._poolService.stake(bundleNftId, amount);
     }
 
 
@@ -229,7 +249,7 @@ abstract contract Pool is
     /// 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)
+    function _closeBundle(NftId bundleNftId)
         internal
         virtual
     {
@@ -251,13 +271,13 @@ abstract contract Pool is
     }
 
 
-    /// @dev Sets the maximum overall capital amound held by this pool.
+    /// @dev Sets the maximum balance amound held by this pool.
     /// Function may only be called by pool owner.
-    function _setMaxCapitalAmount(Amount maxCapitalAmount)
+    function _setMaxBalanceAmount(Amount maxBalanceAmount)
         internal
         virtual
     {
-        _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
+        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
     }
 
     /// @dev Sets the required role to create/own bundles.
@@ -287,21 +307,19 @@ abstract contract Pool is
         _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
     }
 
-    /// @dev Creates a new bundle using the provided parameter values.
+    /// @dev Creates a new empty bundle using the provided parameter values.
     function _createBundle(
         address bundleOwner,
         Fee memory fee,
-        Amount amount,
         Seconds lifetime, 
         bytes memory filter
     )
         internal
-        returns(NftId bundleNftId, Amount netStakedAmount)
+        returns(NftId bundleNftId)
     {
-        (bundleNftId, netStakedAmount) = _getPoolStorage()._poolService.createBundle(
+        bundleNftId = _getPoolStorage()._poolService.createBundle(
             bundleOwner,
             fee,
-            amount,
             lifetime,
             filter);
 
@@ -320,6 +338,17 @@ abstract contract Pool is
         return _getPoolStorage()._bundleService.withdrawBundleFees(bundleNftId, amount);
     }
 
+    function _processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    )
+        internal
+    {
+        _getPoolStorage()._poolService.processFundedClaim(
+            policyNftId, claimId, availableAmount);
+    }
+
     function _getPoolStorage() private pure returns (PoolStorage storage $) {
         assembly {
             $.slot := POOL_STORAGE_LOCATION_V1