@etherisc/gif-next 0.0.2-d5b7b78-706 → 0.0.2-d5fac82-078

package/contracts/{components → pool}/IPoolComponent.sol

@@ -1,13 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Fee} from "../types/Fee.sol";
-import {IComponent} from "./IComponent.sol";
+import {Amount} from "../type/Amount.sol";
+import {Fee} from "../type/Fee.sol";
+import {IComponent} from "../shared/IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {NftId} from "../types/NftId.sol";
-import {RoleId} from "../types/RoleId.sol";
-import {Seconds} from "../types/Seconds.sol";
-import {UFixed} from "../types/UFixed.sol";
+import {NftId} from "../type/NftId.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {UFixed} from "../type/UFixed.sol";
 
 /// @dev pool components hold and manage the collateral to cover active policies
 /// pools come in different flavors
@@ -18,17 +19,17 @@ interface IPoolComponent is IComponent {
 
     error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
 
-    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, uint256 collateralizationAmount);
+    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, uint256 amount) external;
+    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, uint256 amount) external;
+    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
@@ -37,7 +38,7 @@ interface IPoolComponent is IComponent {
 
     /// @dev locks the specified bundle
     /// a bundle to be locked MUST be in active state
-    /// locked bundles may not be used to underwrite any new policy
+    /// locked bundles may not be used to collateralize any new policy
     function lockBundle(NftId bundleNftId) external;
 
     /// @dev unlocks the specified bundle
@@ -61,7 +62,7 @@ interface IPoolComponent is IComponent {
 
     /// @dev sets the maximum overall capital amound held by this pool
     /// function may only be called by pool owner
-    function setMaxCapitalAmount(uint256 maxCapitalAmount) external;
+    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
 
     /// @dev sets the required role to create/own bundles
     /// may only be called once after setting up a pool
@@ -88,7 +89,7 @@ interface IPoolComponent is IComponent {
         bytes memory applicationData,
         NftId bundleNftId, 
         bytes memory bundleFilter,
-        uint256 collateralizationAmount
+        Amount collateralizationAmount
     ) external;
 
     /// @dev returns true iff the application matches with the bundle 
@@ -99,7 +100,7 @@ interface IPoolComponent is IComponent {
         bytes memory applicationData,
         NftId bundleNftId, 
         bytes memory bundleFilter,
-        uint256 collateralizationAmount
+        Amount collateralizationAmount
     )
         external
         view

package/contracts/pool/IPoolService.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Amount} from "../type/Amount.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 {IPolicy} from "../instance/module/IPolicy.sol";
+import {IService} from "../shared/IService.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {StateId} from "../type/StateId.sol";
+
+interface IPoolService is IService {
+
+    event LogPoolServiceMaxCapitalAmountUpdated(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;
+
+    /// @dev sets the max capital amount for the calling pool
+    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
+
+    /// @dev set pool sepecific fees
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) 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
+    /// - retention level < 1: a part of the coverage is provided by the specified bundle, the rest by the pool component
+    /// in which case the pool component might hold a re-insurance policy
+    /// may only be called by the policy service for unlocked pool components
+    function lockCollateral(
+        IInstance instance, 
+        NftId productNftId,
+        NftId applicationNftId,
+        IPolicy.PolicyInfo memory applicationInfo,
+        Amount premiumAmount
+    ) external;
+
+
+    /// @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, 
+        NftId policyNftId, 
+        IPolicy.PolicyInfo memory policyInfo
+    ) external;
+
+
+    /// @dev reduces the locked collateral in the bundle associated with the specified policy
+    /// 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(
+        IInstance instance, 
+        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
+    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); // the nft id of the newly created bundle
+
+
+    /// @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
+    /// bundle fees and remaining capital (after deduction of the performance fee) will be transferred to the bundle owner
+    /// may only be called by registered and unlocked pool components
+    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, Amount actualAmountTransferred) 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 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);
+}

package/contracts/{components → pool}/Pool.sol

@@ -1,20 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Component} from "./Component.sol";
-import {Fee, FeeLib} from "../types/Fee.sol";
-import {IBundleService} from "../instance/service/IBundleService.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Component} from "../shared/Component.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
+import {IBundleService} from "./IBundleService.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
-import {IPoolService} from "../instance/service/IPoolService.sol";
+import {IPoolService} from "./IPoolService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {NftId, NftIdLib} from "../types/NftId.sol";
-import {POOL} from "../types/ObjectType.sol";
-import {RoleId, PUBLIC_ROLE} from "../types/RoleId.sol";
-import {Seconds} from "../types/Seconds.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {BUNDLE, POOL} from "../type/ObjectType.sol";
+import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
+import {Seconds} from "../type/Seconds.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {UFixed, UFixedLib} from "../types/UFixed.sol";
-
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
 
 abstract contract Pool is
     Component, 
@@ -61,8 +60,8 @@ abstract contract Pool is
         initializeComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, registryData);
 
         PoolStorage storage $ = _getPoolStorage();
-        $._poolService = getInstance().getPoolService();
-        $._bundleService = getInstance().getBundleService();
+        $._poolService = IPoolService(_getServiceAddress(POOL())); 
+        $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
 
         registerInterface(type(IPoolComponent).interfaceId);
     }
@@ -70,7 +69,7 @@ abstract contract Pool is
 
     function stake(
         NftId bundleNftId, 
-        uint256 amount
+        Amount amount
     )
         public
         virtual
@@ -83,7 +82,7 @@ abstract contract Pool is
 
     function unstake(
         NftId bundleNftId, 
-        uint256 amount
+        Amount amount
     )
         public
         virtual
@@ -133,7 +132,7 @@ abstract contract Pool is
         //restricted()
         onlyBundleOwner(bundleNftId)
     {
-        _getPoolStorage()._bundleService.close(bundleNftId);
+        _getPoolStorage()._poolService.closeBundle(bundleNftId);
     }
 
 
@@ -150,7 +149,7 @@ abstract contract Pool is
     }
 
 
-    function setMaxCapitalAmount(uint256 maxCapitalAmount)
+    function setMaxCapitalAmount(Amount maxCapitalAmount)
         public
         virtual
         restricted()
@@ -190,7 +189,7 @@ abstract contract Pool is
         bytes memory applicationData,
         NftId bundleNftId, 
         bytes memory bundleFilter,
-        uint256 collateralizationAmount
+        Amount collateralizationAmount
     )
         public
         virtual
@@ -219,7 +218,7 @@ abstract contract Pool is
         bytes memory applicationData,
         NftId bundleNftId, 
         bytes memory bundleFilter,
-        uint256 collateralizationAmount
+        Amount collateralizationAmount
     )
         public
         view
@@ -239,14 +238,14 @@ abstract contract Pool is
     function _createBundle(
         address bundleOwner,
         Fee memory fee,
-        uint256 amount,
+        Amount amount,
         Seconds lifetime, 
         bytes memory filter
     )
         internal
         returns(NftId bundleNftId)
     {
-        bundleNftId = _getPoolStorage()._bundleService.create(
+        bundleNftId = _getPoolStorage()._poolService.createBundle(
             bundleOwner,
             fee,
             amount,
@@ -274,11 +273,15 @@ abstract contract Pool is
             getToken(),
             TokenHandler(address(0)), // will be created by GIF service during registration
             address(this), // contract is its own wallet
+            AmountLib.zero(), // balance amount
+            AmountLib.zero(), // fee amount
             abi.encode(
                 IComponents.PoolInfo(
                     NftIdLib.zero(), // will be set when GIF registers the related product
                     PUBLIC_ROLE(), // bundleOwnerRole
-                    type(uint256).max, // maxCapitalAmount,
+                    AmountLib.max(), // maxCapitalAmount,
+                    AmountLib.zero(), // initial balance amount
+                    AmountLib.zero(), // initial fee amount
                     isNftInterceptor(), // isInterceptingBundleTransfers
                     false, // isExternallyManaged,
                     false, // isVerifyingApplications,