@etherisc/gif-next 0.0.2-e9a637d-547 → 0.0.2-eadf4ad-211

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";
 
@@ -53,12 +53,13 @@ contract BundleService is
         initializer
         virtual override
     {
-        address registryAddress;
-        address initialOwner;
-        (registryAddress, initialOwner) = abi.decode(data, (address, address));
-        // TODO while PoolService is not deployed in PoolServiceManager constructor
-        //      owner is PoolServiceManager deployer
-        initializeService(registryAddress, address(0), owner);
+        (
+            address registryAddress,, 
+            //address managerAddress
+            address authority
+        ) = abi.decode(data, (address, address, address));
+
+        initializeService(registryAddress, authority, owner);
         registerInterface(type(IBundleService).interfaceId);
     }
 
@@ -75,16 +76,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 +93,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,31 +116,16 @@ contract BundleService is
         IInstance instance,
         NftId poolNftId,
         address owner, 
-        Fee memory fee, 
+        Fee memory bundleFee, 
         Amount stakingAmount, 
         Seconds lifetime, 
         bytes calldata filter
     )
         external
         override
-        // TODO add restricted and add authz for pool service
+        restricted
         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 +140,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 +168,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,11 +189,11 @@ 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
+        restricted
     {
         InstanceReader instanceReader = instance.getInstanceReader();
         StateId bundleState = instanceReader.getMetadata(bundleNftId.toKey32(BUNDLE())).state;
@@ -212,7 +205,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 +213,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 +227,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 +280,7 @@ contract BundleService is
         external
         virtual
     {
-        (,, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+        (,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
 
         // udpate bundle state
         instance.getInstanceStore().updateBundleState(bundleNftId, ACTIVE());
@@ -300,7 +299,7 @@ contract BundleService is
     ) 
         external
         virtual
-        // TODO add restricted and autz for pool service
+        restricted
     {
         // udpate bundle state
         instance.getInstanceStore().updateBundleState(bundleNftId, CLOSED());
@@ -320,10 +319,10 @@ contract BundleService is
     function increaseBalance(
         IInstance instance,
         NftId bundleNftId, 
-        uint256 premiumAmount
+        Amount premiumAmount
     ) 
         external
-        onlyService 
+        restricted
     {
         InstanceReader instanceReader = instance.getInstanceReader();
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
@@ -337,20 +336,17 @@ contract BundleService is
     function releaseCollateral(IInstance instance,
         NftId policyNftId, 
         NftId bundleNftId, 
-        uint256 collateralAmount
+        Amount collateralAmount
     ) 
         external
-        onlyService 
+        restricted 
     {
         InstanceReader instanceReader = instance.getInstanceReader();
         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 +360,25 @@ 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
+        restricted
     {
-        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/pool/BundleServiceManager.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+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 "../type/ObjectType.sol";
+
+contract BundleServiceManager is ProxyManager {
+
+    BundleService private _bundleService;
+
+    /// @dev initializes proxy manager with pool service implementation 
+    constructor(
+        address authority, 
+        address registryAddress,
+        bytes32 salt
+    ) 
+        ProxyManager(registryAddress)
+    {
+        BundleService bundleSrv = new BundleService{salt: salt}();
+        bytes memory data = abi.encode(registryAddress, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
+            address(bundleSrv), 
+            data,
+            salt);
+
+        _bundleService = BundleService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getBundleService()
+        external
+        view
+        returns (BundleService)
+    {
+        return _bundleService;
+    }
+
+}

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;
 }