@etherisc/gif-next 0.0.2-e9a637d-547 → 0.0.2-ead1eb0-841

package/contracts/instance/module/IRisk.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
+import {NftId} from "../../type/NftId.sol";
 
 interface IRisk {
     struct RiskInfo {

package/contracts/instance/module/ISetup.sol

@@ -3,11 +3,11 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-import {Fee} from "../../types/Fee.sol";
-import {NftId} from "../../types/NftId.sol";
-import {RoleId} from "../../types/RoleId.sol";
+import {Fee} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
+import {RoleId} from "../../type/RoleId.sol";
 import {TokenHandler} from "../../shared/TokenHandler.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
 interface ISetup {
 

package/contracts/instance/module/ITreasury.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-import {Fee} from "../../types/Fee.sol";
-import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
 import {TokenHandler} from "../../shared/TokenHandler.sol";
 
 interface ITreasury {

package/contracts/{instance/service → pool}/BundleService.sol

@@ -1,37 +1,37 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {IBundle} from "../../instance/module/IBundle.sol";
-import {IComponents} from "../module/IComponents.sol";
-import {IRegistry} from "../../registry/IRegistry.sol";
-import {IInstance} from "../../instance/IInstance.sol";
-import {TokenHandler} from "../../instance/module/ITreasury.sol";
-import {ISetup} from "../module/ISetup.sol";
-import {IPolicy} from "../module/IPolicy.sol";
-
-import {IVersionable} from "../../shared/IVersionable.sol";
-import {INftOwnable} from "../../shared/INftOwnable.sol";
-import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
-import {ObjectType, POOL, BUNDLE} from "../../types/ObjectType.sol";
-import {POOL_OWNER_ROLE, RoleId} from "../../types/RoleId.sol";
-import {Pool} from "../../components/Pool.sol";
-
-import {Amount, AmountLib} from "../../types/Amount.sol";
-import {Fee, FeeLib} from "../../types/Fee.sol";
-import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../../types/StateId.sol";
-import {Seconds} from "../../types/Seconds.sol";
-import {TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
-import {Version, VersionLib} from "../../types/Version.sol";
-import {Versionable} from "../../shared/Versionable.sol";
-
-import {IService} from "../../shared/IService.sol";
-import {Service} from "../../shared/Service.sol";
-import {BundleManager} from "../BundleManager.sol";
-import {ComponentService} from "../base/ComponentService.sol";
+import {IBundle} from "../instance/module/IBundle.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {TokenHandler} from "../instance/module/ITreasury.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+
+import {IVersionable} from "../shared/IVersionable.sol";
+import {INftOwnable} from "../shared/INftOwnable.sol";
+import {NftId, NftIdLib, zeroNftId} from "../type/NftId.sol";
+import {ObjectType, POOL, BUNDLE} from "../type/ObjectType.sol";
+import {POOL_OWNER_ROLE, RoleId} from "../type/RoleId.sol";
+import {Pool} from "./Pool.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
+import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../type/StateId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+import {Versionable} from "../shared/Versionable.sol";
+
+import {IService} from "../shared/IService.sol";
+import {Service} from "../shared/Service.sol";
+import {BundleManager} from "../instance/BundleManager.sol";
+import {ComponentService} from "../shared/ComponentService.sol";
 import {IBundleService} from "./IBundleService.sol";
-import {IRegistryService} from "../../registry/IRegistryService.sol";
-import {InstanceService} from "../InstanceService.sol";
-import {InstanceReader} from "../InstanceReader.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {InstanceService} from "../instance/InstanceService.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
 
 string constant BUNDLE_SERVICE_NAME = "BundleService";
 
@@ -75,16 +75,16 @@ contract BundleService is
     function _updatePoolWithStakes(
         IInstance instance,
         NftId poolNftId,
-        uint256 stakingAmount
+        Amount stakingAmount
     )
         internal
         returns (
             TokenHandler tokenHandler,
             address wallet,
-            uint256 netStakingAmount
+            Amount netStakingAmount
         )
     {
-        if(stakingAmount > 0) {
+        if(stakingAmount.gtz()) {
             InstanceReader instanceReader = instance.getInstanceReader();
             IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
 
@@ -92,16 +92,16 @@ contract BundleService is
             wallet = componentInfo.wallet;
 
             IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
-            uint256 poolFeeAmount;
+            Amount poolFeeAmount;
 
             // calculate pool fee and net staking amount
             (poolFeeAmount, netStakingAmount) = FeeLib.calculateFee(poolInfo.stakingFee, stakingAmount);
 
             // update pool balance and fee amount
-            poolInfo.balanceAmount += netStakingAmount;
+            poolInfo.balanceAmount = poolInfo.balanceAmount + netStakingAmount;
 
-            if(poolFeeAmount > 0) {
-                poolInfo.feeAmount += poolFeeAmount;
+            if(poolFeeAmount.gtz()) {
+                poolInfo.feeAmount = poolInfo.feeAmount + poolFeeAmount;
             }
 
             // save updated pool info
@@ -115,7 +115,7 @@ contract BundleService is
         IInstance instance,
         NftId poolNftId,
         address owner, 
-        Fee memory fee, 
+        Fee memory bundleFee, 
         Amount stakingAmount, 
         Seconds lifetime, 
         bytes calldata filter
@@ -125,21 +125,6 @@ contract BundleService is
         // TODO add restricted and add authz for pool service
         returns(NftId bundleNftId)
     {
-        InstanceReader instanceReader = instance.getInstanceReader();
-
-        // create initial bundle info
-        IBundle.BundleInfo  memory bundleInfo = IBundle.BundleInfo(
-            poolNftId,
-            fee,
-            filter,
-            stakingAmount,
-            AmountLib.zero(),
-            AmountLib.zero(),
-            lifetime,
-            TimestampLib.blockTimestamp().addSeconds(lifetime),
-            zeroTimestamp()
-        );
-
         // register bundle with registry
         bundleNftId = getRegistryService().registerBundle(
             IRegistry.ObjectInfo(
@@ -154,23 +139,27 @@ contract BundleService is
         );
 
         // create bundle info in instance
-        instance.getInstanceStore().createBundle(bundleNftId, bundleInfo);
+        instance.getInstanceStore().createBundle(
+            bundleNftId, 
+            IBundle.BundleInfo(
+                poolNftId,
+                bundleFee,
+                filter,
+                stakingAmount,
+                AmountLib.zero(),
+                AmountLib.zero(),
+                lifetime,
+                TimestampLib.blockTimestamp().addSeconds(lifetime),
+                zeroTimestamp()));
 
         // put bundle under bundle managemet
         BundleManager bundleManager = instance.getBundleManager();
         bundleManager.add(bundleNftId);
-        
-        // transfer full staking amount to pool wallet
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        componentInfo.tokenHandler.transfer(
-            owner,
-            componentInfo.wallet,
-            stakingAmount.toInt()
-        );
 
         // TODO add logging
     }
 
+
     function setFee(
         NftId bundleNftId,
         Fee memory fee
@@ -178,15 +167,18 @@ contract BundleService is
         external
         override
     {
-        (NftId poolNftId, IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
-
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
-        require(bundleInfo.poolNftId.gtz(), "ERROR:PLS-010:BUNDLE_UNKNOWN");
-        require(poolNftId == bundleInfo.poolNftId, "ERROR:PLS-011:BUNDLE_POOL_MISMATCH");
+        if(bundleInfo.poolNftId.eqz()) {
+            revert ErrorBundleServiceBundleUnknown(bundleNftId);
+        }
 
-        bundleInfo.fee = fee;
+        if(bundleInfo.poolNftId != poolNftId) {
+            revert ErrorBundleServiceBundlePoolMismatch(bundleNftId, bundleInfo.poolNftId, poolNftId);
+        }
 
+        bundleInfo.fee = fee;
         instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
     }
 
@@ -196,8 +188,8 @@ contract BundleService is
         IInstance instance,
         NftId policyNftId, 
         NftId bundleNftId, 
-        uint256 collateralAmount, // required amount to collateralize policy
-        uint256 premiumAmount // premium part that reaches bundle for this policy
+        Amount collateralAmount, // required amount to collateralize policy
+        Amount premiumAmount // premium part that reaches bundle for this policy
     ) 
         external
         onlyService // TODO replace with restricted + appropriate granting
@@ -212,7 +204,7 @@ contract BundleService is
         }
 
         // ensure bundle capacity is sufficent to collateralize policy
-        uint capacity = bundleInfo.capitalAmount.toInt() + premiumAmount - bundleInfo.lockedAmount.toInt();
+        Amount capacity = bundleInfo.capitalAmount + premiumAmount - bundleInfo.lockedAmount;
         if(capacity < collateralAmount) {
             revert ErrorBundleServiceCapacityInsufficient(bundleNftId, capacity, collateralAmount);
         }
@@ -220,7 +212,7 @@ contract BundleService is
         // TODO add more validation
         
         // updated locked amount
-        bundleInfo.lockedAmount = AmountLib.toAmount(bundleInfo.lockedAmount.toInt() + collateralAmount);
+        bundleInfo.lockedAmount = bundleInfo.lockedAmount + collateralAmount;
 
         // update capital and fees when premiums are involved
         _updateBundleWithPremium(instance, bundleNftId, bundleInfo, premiumAmount);
@@ -234,37 +226,43 @@ contract BundleService is
         IInstance instance,
         NftId bundleNftId,
         IBundle.BundleInfo memory bundleInfo,
-        uint256 premiumAmount
+        Amount premiumAmount
     )
         internal
     {
         // update bundle capital and fee amounts
-        if(premiumAmount > 0) {
+        if(premiumAmount.gtz()) {
             // calculate fees and net premium amounts
             (
-                uint256 feeAmount, 
-                uint256 netPremiumAmount
+                , 
+                Amount netPremiumAmount
             ) = FeeLib.calculateFee(bundleInfo.fee, premiumAmount);
 
             // update bundle info with additional capital
-            bundleInfo.capitalAmount = AmountLib.toAmount(bundleInfo.capitalAmount.toInt() + netPremiumAmount);
-
-            // update bundle info with additional fees
-            if(feeAmount > 0) {
-                bundleInfo.feeAmount = AmountLib.toAmount(bundleInfo.feeAmount.toInt() + feeAmount);
-            }
+            bundleInfo.capitalAmount = bundleInfo.capitalAmount + netPremiumAmount;
         }
 
         // save updated bundle info
         instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
     }
 
+    function updateBundleFees(
+        IInstance instance,
+        NftId bundleNftId,
+        Amount feeAmount
+    )
+        external
+    {
+        IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
+        bundleInfo.feeAmount = bundleInfo.feeAmount.add(feeAmount);
+        instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
+    }
 
     function lock(NftId bundleNftId) 
         external
         virtual
     {
-        (,, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+        (,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
 
         // udpate bundle state
         instance.getInstanceStore().updateBundleState(bundleNftId, PAUSED());
@@ -281,7 +279,7 @@ contract BundleService is
         external
         virtual
     {
-        (,, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+        (,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
 
         // udpate bundle state
         instance.getInstanceStore().updateBundleState(bundleNftId, ACTIVE());
@@ -320,7 +318,7 @@ contract BundleService is
     function increaseBalance(
         IInstance instance,
         NftId bundleNftId, 
-        uint256 premiumAmount
+        Amount premiumAmount
     ) 
         external
         onlyService 
@@ -337,7 +335,7 @@ contract BundleService is
     function releaseCollateral(IInstance instance,
         NftId policyNftId, 
         NftId bundleNftId, 
-        uint256 collateralAmount
+        Amount collateralAmount
     ) 
         external
         onlyService 
@@ -346,11 +344,8 @@ contract BundleService is
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
 
         // reduce locked amount by released collateral amount
-        bundleInfo.lockedAmount = AmountLib.toAmount(bundleInfo.lockedAmount.toInt() - collateralAmount);
-
+        bundleInfo.lockedAmount = bundleInfo.lockedAmount - collateralAmount;
         instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
-        
-        _unlinkPolicy(instance, policyNftId);
     }
 
     /// @dev links policy to bundle
@@ -364,68 +359,24 @@ contract BundleService is
         if (policyInfo.activatedAt.gtz() && policyInfo.activatedAt < TimestampLib.blockTimestamp()) {
             revert BundleManager.ErrorBundleManagerPolicyAlreadyActivated(policyNftId);
         }
-
+        
         BundleManager bundleManager = instance.getBundleManager();
         bundleManager.linkPolicy(policyNftId);
     }
 
-        /// @dev unlinks policy from bundle
-    function _unlinkPolicy(IInstance instance, NftId policyNftId) 
-        internal
+    /// @dev unlinks policy from bundle
+    function unlinkPolicy(
+        IInstance instance, 
+        NftId policyNftId
+    ) 
+        external
+        virtual
     {
-        InstanceReader instanceReader = instance.getInstanceReader();
-        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
-
-        // ensure policy has no open claims
-        if (policyInfo.openClaimsCount > 0) {
-            revert BundleManager.ErrorBundleManagerPolicyWithOpenClaims(
-                policyNftId, 
-                policyInfo.openClaimsCount);
-        }
-
         // ensure policy is closeable
-        if ( TimestampLib.blockTimestamp() < policyInfo.expiredAt
-            && policyInfo.payoutAmount < policyInfo.sumInsuredAmount)
-        {
-            revert BundleManager.ErrorBundleManagerPolicyNotCloseable(policyNftId);
+        if (!instance.getInstanceReader().policyIsCloseable(policyNftId)) {
+            revert ErrorBundleServicePolicyNotCloseable(policyNftId);
         }
-        
-        BundleManager bundleManager = instance.getBundleManager();
-        bundleManager.unlinkPolicy(policyNftId);
-    }
-
-    // TODO move this to pool service
-    function _processStakingByTreasury(
-        InstanceReader instanceReader,
-        NftId poolNftId,
-        NftId bundleNftId,
-        Amount stakingAmount
-    )
-        internal
-    {
-        // process token transfer(s)
-        if(stakingAmount.gtz()) {
-            IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-            IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
-
-            TokenHandler tokenHandler = componentInfo.tokenHandler;
-            address bundleOwner = getRegistry().ownerOf(bundleNftId);
-            Fee memory stakingFee = poolInfo.stakingFee;
-
-            // pool fee and bundle capital book keeping
-            if (FeeLib.gtz(stakingFee)) {
-                (uint256 stakingFeeAmount, uint256 netAmount) = FeeLib.calculateFee(stakingFee, stakingAmount.toInt());
-
 
-                // TODO: track staking fees in pool's state (issue #177)
-            }
-
-            // transfer full staking amount to pool wallet
-            tokenHandler.transfer(
-                bundleOwner,
-                componentInfo.wallet,
-                stakingAmount.toInt()
-            );
-        }
+        instance.getBundleManager().unlinkPolicy(policyNftId);
     }
 }

package/contracts/{instance/service → pool}/BundleServiceManager.sol

@@ -1,12 +1,12 @@
 // 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 "../shared/IVersionable.sol";
+import {ProxyManager} from "../shared/ProxyManager.sol";
 import {BundleService} from "./BundleService.sol";
-import {Registry} from "../../registry/Registry.sol";
-import {RegistryService} from "../../registry/RegistryService.sol";
-import {ObjectType, REGISTRY} from "../../types/ObjectType.sol";
+import {Registry} from "../registry/Registry.sol";
+import {RegistryService} from "../registry/RegistryService.sol";
+import {ObjectType, REGISTRY} from "../type/ObjectType.sol";
 
 contract BundleServiceManager is ProxyManager {
 

package/contracts/{instance/service → pool}/IBundleService.sol

@@ -1,26 +1,31 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {Amount} from "../../types/Amount.sol";
-import {NftId} from "../../types/NftId.sol";
-import {Fee} from "../../types/Fee.sol";
-import {IService} from "../../shared/IService.sol";
-import {IBundle} from "../module/IBundle.sol";
-import {IInstance} from "../../instance/IInstance.sol";
-import {Seconds} from "../../types/Seconds.sol";
-import {StateId} from "../../types/StateId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+import {Amount} from "../type/Amount.sol";
+import {NftId} from "../type/NftId.sol";
+import {Fee} from "../type/Fee.sol";
+import {IService} from "../shared/IService.sol";
+import {IBundle} from "../instance/module/IBundle.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 
 interface IBundleService is IService {
 
     event LogBundleServiceBundleActivated(NftId bundleNftId);
     event LogBundleServiceBundleLocked(NftId bundleNftId);
 
-    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
+    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, Amount amount);
     error ErrorBundleServiceBundleNotOpen(NftId bundleNftId, StateId state, Timestamp expiredAt);
-    error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, uint capacityAmount, uint collateralAmount);
+    error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, Amount capacityAmount, Amount collateralAmount);
     error ErrorBundleServiceBundleWithOpenPolicies(NftId bundleNftId, uint256 openPoliciesCount);
 
+    error ErrorBundleServiceBundleUnknown(NftId bundleNftId);
+    error ErrorBundleServiceBundlePoolMismatch(NftId bundleNftId, NftId expectedPool, NftId actualPool);
+
+    error ErrorBundleServicePolicyNotCloseable(NftId policyNftId);
+
     /// @dev create a new bundle for the specified attributes
     /// may only be called by pool service
     function create(
@@ -35,6 +40,13 @@ interface IBundleService is IService {
         external 
         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);
+
+    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
     /// @dev locks the specified bundle, locked bundles are not available to collateralize new policies
     /// only active bundles may be locked
     /// may only be called by registered and unlocked pool components
@@ -71,23 +83,36 @@ interface IBundleService is IService {
         IInstance instanceNftId, 
         NftId policyNftId, 
         NftId bundleNftId, 
-        uint256 collateralAmount, 
-        uint256 premium // premium amount after pool fee
+        Amount collateralAmount, 
+        Amount premiumAmount // premium after pool fee
     ) external;
 
-
     /// @dev releases the specified collateral in the bundle
     /// may only be called by pool service
     function releaseCollateral(
         IInstance instance, 
         NftId policyNftId, 
         NftId bundleNftId, 
-        uint256 collateralAmount
+        Amount collateralAmount
     ) external;
 
-    function increaseBalance(IInstance instance, NftId bundleNftId,  uint256 amount) external;
+    /// @dev unlink policy from bundle
+    /// policy may only be unlinked if policy is closeable
+    /// may only be called by pool service
+    function unlinkPolicy(
+        IInstance instance, 
+        NftId policyNftId
+    ) external;
 
-    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    /// @dev updates the bundle's fees of with the provided fee amount
+    function updateBundleFees(
+        IInstance instance,
+        NftId bundleNftId,
+        Amount feeAmount
+    ) external;
 
-    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    function increaseBalance(
+        IInstance instance, 
+        NftId bundleNftId,  
+        Amount amount) external;
 }

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