@etherisc/gif-next 0.0.2-e922e07-736 → 0.0.2-e94f4c7-084

package/contracts/instance/service/ClaimService.sol

@@ -22,18 +22,19 @@ import {TokenHandler} from "../../shared/TokenHandler.sol";
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
 
+import {Amount, AmountLib} from "../../types/Amount.sol";
 import {Timestamp, TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {UFixed, UFixedLib} from "../../types/UFixed.sol";
 import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
 import {ObjectType, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, CLAIM, BUNDLE} from "../../types/ObjectType.sol";
-import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE, CLOSED} from "../../types/StateId.sol";
+import {SUBMITTED, ACTIVE, KEEP_STATE, DECLINED, CONFIRMED, CLOSED} from "../../types/StateId.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {Fee, FeeLib} from "../../types/Fee.sol";
 import {ReferralId} from "../../types/Referral.sol";
 import {RiskId} from "../../types/RiskId.sol";
 import {StateId} from "../../types/StateId.sol";
-import {ClaimId} from "../../types/ClaimId.sol";
-import {PayoutId} from "../../types/PayoutId.sol";
+import {ClaimId, ClaimIdLib} from "../../types/ClaimId.sol";
+import {PayoutId, PayoutIdLib} from "../../types/PayoutId.sol";
 import {Version, VersionLib} from "../../types/Version.sol";
 
 import {ComponentService} from "../base/ComponentService.sol";
@@ -50,6 +51,7 @@ contract ClaimService is
     IClaimService
 {
 
+    IPoolService internal _poolService;
 
     function _initialize(
         address owner, 
@@ -64,77 +66,140 @@ contract ClaimService is
         address initialOwner;
         (registryAddress, initialOwner) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, owner);
+        initializeService(registryAddress, address(0), owner);
+
+        _poolService = IPoolService(getRegistry().getServiceAddress(POOL(), getVersion().toMajorPart()));
+
         registerInterface(type(IClaimService).interfaceId);
     }
 
 
-    function getDomain() public pure override(IService, Service) returns(ObjectType) {
+    function getDomain() public pure override returns(ObjectType) {
         return CLAIM();
     }
 
 
-    function createClaim(
+    function submit(
+        IInstance instance,
         NftId policyNftId, 
-        uint256 claimAmount,
+        ClaimId claimId, 
+        Amount claimAmount,
         bytes memory claimData
     )
         external
         virtual
-        returns (ClaimId)
+        // TODO add restricted and grant to policy service
     {
-
+        instance.createClaim(
+            policyNftId, 
+            claimId, 
+            IPolicy.ClaimInfo(
+                claimAmount,
+                AmountLib.zero(), // paidAmount
+                0, // payoutsCount
+                0, // openPayoutsCount
+                claimData,
+                TimestampLib.zero())); // closedAt
     }
 
 
-    function confirmClaim(NftId policyNftId, ClaimId claimId, uint256 claimAmount)
+    function confirm(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount confirmedAmount
+    )
         external
         virtual
-        // solhint-disable-next-line no-empty-blocks
     {
-
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
+        claimInfo.claimAmount = confirmedAmount;
+        instance.updateClaim(policyNftId, claimId, claimInfo, CONFIRMED());
     }
 
-
-    function declineClaim(NftId policyNftId, ClaimId claimId)
+    function decline(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId
+    )
         external
         virtual
-        // solhint-disable-next-line no-empty-blocks
     {
-
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
+        claimInfo.closedAt = TimestampLib.blockTimestamp();
+        instance.updateClaim(policyNftId, claimId, claimInfo, DECLINED());
     }
 
 
-    function closeClaim(NftId policyNftId, ClaimId claimId)
+    function close(
+        IInstance instance,
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId
+    )
         external
         virtual
-        // solhint-disable-next-line no-empty-blocks
     {
-
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, CONFIRMED());
+
+        // check claim has no open payouts
+        if(claimInfo.openPayoutsCount > 0) {
+            revert ErrorClaimServiceClaimWithOpenPayouts(
+                policyNftId, 
+                claimId, 
+                claimInfo.openPayoutsCount);
+        }
+
+        // check claim paid amount matches with claim amount
+        if(claimInfo.paidAmount.toInt() < claimInfo.claimAmount.toInt()) {
+            revert ErrorClaimServiceClaimWithMissingPayouts(
+                policyNftId, 
+                claimId, 
+                claimInfo.claimAmount,
+                claimInfo.paidAmount);
+        }
+
+        claimInfo.closedAt = TimestampLib.blockTimestamp();
+        instance.updateClaim(policyNftId, claimId, claimInfo, CLOSED());
     }
 
 
     function createPayout(
+        IInstance instance,
         NftId policyNftId, 
-        ClaimId claimId,
-        uint256 payoutAmount,
+        PayoutId payoutId,
+        Amount payoutAmount,
         bytes calldata payoutData
     )
         external
         virtual
-        returns(PayoutId payoutId)
-        // solhint-disable-next-line no-empty-blocks
+        // TODO add restricted and grant to policy service
     {
-
+        instance.createPayout(
+            policyNftId, 
+            payoutId, 
+            IPolicy.PayoutInfo(
+                payoutId.toClaimId(),
+                payoutAmount,
+                payoutData,
+                TimestampLib.zero()));
     }
 
 
-    function payoutExecuted(
+    function processPayout(
+        IInstance instance,
+        InstanceReader instanceReader,
         NftId policyNftId, 
         PayoutId payoutId
     )
         external
         virtual
+        returns (
+            Amount amount,
+            bool payoutIsClosingClaim
+        )
         // solhint-disable-next-line no-empty-blocks
     {
 
@@ -143,9 +208,32 @@ contract ClaimService is
 
     // internal functions
 
+    function _verifyClaim(
+        InstanceReader instanceReader,
+        NftId policyNftId, 
+        ClaimId claimId, 
+        StateId expectedState
+    )
+        internal
+        view
+        returns (
+            IPolicy.ClaimInfo memory claimInfo
+        )
+    {
+        // check claim is created state
+        StateId claimState = instanceReader.getClaimState(policyNftId, claimId);
+        if(claimState != expectedState) {
+            revert ErrorClaimServiceClaimNotInExpectedState(
+                policyNftId, claimId, expectedState, claimState);
+        }
+
+        // get claim info
+        claimInfo = instanceReader.getClaimInfo(policyNftId, claimId);
+    }
+
     function _getAndVerifyInstanceAndProduct() internal view returns (Product product) {
         IRegistry.ObjectInfo memory productInfo;
-        (productInfo,) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        (, productInfo,) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
         product = Product(productInfo.objectAddress);
     }
 }

package/contracts/instance/service/DistributionService.sol

@@ -10,10 +10,11 @@ import {IPolicy} from "../module/IPolicy.sol";
 
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {Fee, FeeLib} from "../../types/Fee.sol";
-import {DISTRIBUTION_OWNER_ROLE} from "../../types/RoleId.sol";
+import {PRODUCT_SERVICE_ROLE, DISTRIBUTION_OWNER_ROLE} from "../../types/RoleId.sol";
 import {KEEP_STATE} from "../../types/StateId.sol";
 import {ObjectType, DISTRIBUTION, INSTANCE, DISTRIBUTION, DISTRIBUTOR} from "../../types/ObjectType.sol";
 import {Version, VersionLib} from "../../types/Version.sol";
+import {RoleId} from "../../types/RoleId.sol";
 
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
@@ -59,11 +60,11 @@ contract DistributionService is
         (registryAddress, initialOwner) = abi.decode(data, (address, address));
         // TODO while DistributionService is not deployed in DistributionServiceManager constructor
         //      owner is DistributionServiceManager deployer
-        initializeService(registryAddress, owner);
+        initializeService(registryAddress, address(0), owner);
         registerInterface(type(IDistributionService).interfaceId);
     }
 
-    function getDomain() public pure override(Service, IService) returns(ObjectType) {
+    function getDomain() public pure override returns(ObjectType) {
         return DISTRIBUTION();
     }
 
@@ -87,8 +88,24 @@ contract DistributionService is
         distributionNftId = distributionInfo.nftId;
 
         instance.createDistributionSetup(distributionNftId, distribution.getSetupInfo());
-        getInstanceService().createGifTarget(instanceNftId, distributionAddress, distribution.getName());
-        getInstanceService().grantDistributionDefaultPermissions(instanceNftId, distributionAddress, distribution.getName());
+        // TODO move to distribution?
+        bytes4[][] memory selectors = new bytes4[][](2);
+        selectors[0] = new bytes4[](1);
+        selectors[1] = new bytes4[](2);
+
+        selectors[0][0] = IDistributionComponent.setFees.selector;
+        selectors[1][0] = IDistributionComponent.processRenewal.selector;
+
+        RoleId[] memory roles = new RoleId[](2);
+        roles[0] = DISTRIBUTION_OWNER_ROLE();
+        roles[1] = PRODUCT_SERVICE_ROLE();
+
+        getInstanceService().createGifTarget(
+            instanceNftId, 
+            distributionAddress, 
+            distribution.getName(), 
+            selectors, 
+            roles);
     }
 
     function setFees(
@@ -102,9 +119,8 @@ contract DistributionService is
             revert ErrorIDistributionServiceMinFeeTooHigh(minDistributionOwnerFee.fractionalFee.toInt(), distributionFee.fractionalFee.toInt());
         }
 
-        (IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
+        (NftId distributionNftId, IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
         InstanceReader instanceReader = instance.getInstanceReader();
-        NftId distributionNftId = info.nftId;
 
         ISetup.DistributionSetupInfo memory distSetupInfo = instanceReader.getDistributionSetupInfo(distributionNftId);
         distSetupInfo.minDistributionOwnerFee = minDistributionOwnerFee;
@@ -127,7 +143,7 @@ contract DistributionService is
         external
         returns (DistributorType distributorType)
     {
-        (,NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
+        (NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
 
         {
             ISetup.DistributionSetupInfo memory setupInfo = instance.getInstanceReader().getDistributionSetupInfo(distributionNftId);
@@ -139,22 +155,18 @@ contract DistributionService is
         }
         
         distributorType = DistributorTypeLib.toDistributorType(distributionNftId, name);
-        Key32 key32 = distributorType.toKey32();
-
-        if(!instance.exists(key32)) {
-            IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
-                name,
-                minDiscountPercentage,
-                maxDiscountPercentage,
-                commissionPercentage,
-                maxReferralCount,
-                maxReferralLifetime,
-                allowSelfReferrals,
-                allowRenewals,
-                data);
-
-            instance.createDistributorType(key32, info);
-        }
+        IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo(
+            name,
+            minDiscountPercentage,
+            maxDiscountPercentage,
+            commissionPercentage,
+            maxReferralCount,
+            maxReferralLifetime,
+            allowSelfReferrals,
+            allowRenewals,
+            data);
+
+        instance.createDistributorType(distributorType, info);
     }
 
     function createDistributor(
@@ -163,7 +175,7 @@ contract DistributionService is
         bytes memory data
     ) external returns (NftId distributorNftId)
     {
-        (, NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
+        (NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
 
         distributorNftId = getRegistryService().registerDistributor(
             IRegistry.ObjectInfo(
@@ -192,7 +204,7 @@ contract DistributionService is
         bytes memory data
     ) external virtual
     {
-        (,, IInstance instance) = _getAndVerifyCallingDistribution();
+        (, IInstance instance) = _getAndVerifyCallingDistribution();
         InstanceReader instanceReader = instance.getInstanceReader();
         IDistribution.DistributorInfo memory distributorInfo = instanceReader.getDistributorInfo(distributorNftId);
         distributorInfo.distributorType = distributorType;
@@ -213,7 +225,7 @@ contract DistributionService is
         virtual
         returns (ReferralId referralId)
     {
-        (,NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
+        (NftId distributionNftId, IInstance instance) = _getAndVerifyCallingDistribution();
 
         if (bytes(code).length == 0) {
             revert ErrorIDistributionServiceInvalidReferral(code);
@@ -251,7 +263,7 @@ contract DistributionService is
             data
         );
 
-        instance.createReferral(referralId.toKey32(), info);
+        instance.createReferral(referralId, info);
         return referralId;
     }
 
@@ -271,7 +283,7 @@ contract DistributionService is
             revert ErrorIDistributionServiceReferralInvalid(distributionNftId, referralId);
         }
 
-        (, IInstance instance) = _getAndVerifyDistribution(distributionNftId);
+        IInstance instance = _getInstanceForDistribution(distributionNftId);
         InstanceReader reader = instance.getInstanceReader();
         IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
         IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
@@ -292,7 +304,7 @@ contract DistributionService is
 
         if (isReferral) {
             referralInfo.usedReferrals += 1;
-            instance.updateReferral(referralId.toKey32(), referralInfo, KEEP_STATE());
+            instance.updateReferral(referralId, referralInfo, KEEP_STATE());
 
             if (commissionAmount > 0) {
                 distributorInfo.sumCommisions += commissionAmount;
@@ -312,7 +324,7 @@ contract DistributionService is
         view 
         returns (IPolicy.Premium memory finalPremium)
     {
-        (, IInstance instance) = _getAndVerifyDistribution(distributionNftId);
+        IInstance instance = _getInstanceForDistribution(distributionNftId);
         InstanceReader reader = instance.getInstanceReader();
         
         // first calculate all fixed and variable fees for the distribution - this will defined the fullPremium
@@ -373,7 +385,7 @@ contract DistributionService is
 
     // TODO: zero should return false
     function referralIsValid(NftId distributionNftId, ReferralId referralId) public view returns (bool isValid) {
-        (address distributionAddress, IInstance instance) = _getAndVerifyDistribution(distributionNftId);
+        IInstance instance = _getInstanceForDistribution(distributionNftId);
         IDistribution.ReferralInfo memory info = instance.getInstanceReader().getReferralInfo(referralId);
 
         if (info.distributorNftId.eqz()) {
@@ -388,63 +400,32 @@ contract DistributionService is
         internal
         view
         returns(
-            address distributionAddress,
             NftId distributionNftId,
             IInstance instance
         )
     {
-        ObjectType objectType;
-        (
-            distributionAddress,
-            distributionNftId,
-            objectType,
-            instance
-        ) = _getAndVerifyCaller();
-
-        if(objectType != DISTRIBUTION()) {
-            revert ErrorIDistributionServiceCallerNotDistributor(msg.sender);
+        distributionNftId = getRegistry().getNftId(msg.sender);
+        if (distributionNftId.eqz()) {
+            revert ErrorDistributionServiceCallerNotRegistered(msg.sender);
         }
-    }
 
-    function _getAndVerifyDistribution(NftId distributionNftId)
-        internal
-        view
-        returns(
-            address distributionAddress,
-            IInstance instance
-        )
-    {
         IRegistry.ObjectInfo memory info = getRegistry().getObjectInfo(distributionNftId);
-        IRegistry.ObjectInfo memory parentInfo = getRegistry().getObjectInfo(info.parentNftId);
-        if (parentInfo.objectType != INSTANCE()) {
-            revert ErrorIDistributionServiceParentNftIdNotInstance(distributionNftId, info.parentNftId);
+        if(info.objectType != DISTRIBUTION()) {
+            revert ErrorIDistributionServiceCallerNotDistributor(msg.sender);
         }
-        instance = IInstance(parentInfo.objectAddress);
+
+        address instanceAddress = getRegistry().getObjectInfo(info.parentNftId).objectAddress;
+        instance = IInstance(instanceAddress);
     }
 
-    function _getAndVerifyCaller()
+
+    function _getInstanceForDistribution(NftId distributionNftId)
         internal
         view
-        returns(
-            address objectAddress,
-            NftId objectNftId,
-            ObjectType objectType,
-            IInstance instance
-        )
+        returns(IInstance instance)
     {
-        objectAddress = msg.sender;
-        objectNftId = getRegistry().getNftId(objectAddress);
-        if ( objectNftId.eqz()) {
-            revert ErrorIServiceCallerUnknown(objectAddress);
-        }
-        IRegistry.ObjectInfo memory info = getRegistry().getObjectInfo(objectNftId);
-        objectType = info.objectType;
-
-        IRegistry.ObjectInfo memory parentInfo = getRegistry().getObjectInfo(info.parentNftId);
-        if (parentInfo.objectType != INSTANCE()) {
-            revert ErrorIDistributionServiceParentNftIdNotInstance(objectNftId, info.parentNftId);
-        }
-        instance = IInstance(parentInfo.objectAddress);
+        NftId instanceNftId = getRegistry().getObjectInfo(distributionNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
     }
-
 }

package/contracts/instance/service/IApplicationService.sol

@@ -2,24 +2,20 @@
 pragma solidity ^0.8.19;
 
 import {IPolicy} from "../module/IPolicy.sol";
-import {IRisk} from "../module/IRisk.sol";
 import {IService} from "../../shared/IService.sol";
 
 import {NftId} from "../../types/NftId.sol";
+import {ObjectType} from "../../types/ObjectType.sol";
 import {ReferralId} from "../../types/Referral.sol";
 import {RiskId} from "../../types/RiskId.sol";
 import {Seconds} from "../../types/Seconds.sol";
-import {StateId} from "../../types/StateId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
-import {UFixed} from "../../types/UFixed.sol";
-import {Fee} from "../../types/Fee.sol";
 
 /// @dev gif service responsible for creating applications
 /// only product components may call transaction functions
 interface IApplicationService is IService {
     
-    error IApplicationServicePolicyNotApplied(NftId applicationNftId);
-    error IApplicationServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
+    error ErrorApplicationServiceNotProduct(NftId callerNftId, ObjectType callerType);
+    error ErrorApplicationServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
 
     /// @dev creates a new application based on the specified attributes
     /// may only be called by a product component

package/contracts/instance/service/IBundleService.sol

@@ -1,6 +1,7 @@
 // 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";
@@ -8,48 +9,94 @@ 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";
 
 interface IBundleService is IService {
-    error ErrorIBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
 
-    function createBundle(
-        address owner,
-        Fee memory fee, 
-        uint256 amount,
-        Seconds lifetime, 
-        bytes calldata filter
-    ) external returns(NftId bundleNftId);
+    event LogBundleServiceBundleActivated(NftId bundleNftId);
+    event LogBundleServiceBundleLocked(NftId bundleNftId);
 
-    function setBundleFee(
+    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
+    error ErrorBundleServiceBundleNotOpen(NftId bundleNftId, StateId state, Timestamp expiredAt);
+    error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, uint capacityAmount, uint collateralAmount);
+    error ErrorBundleServiceBundleWithOpenPolicies(NftId bundleNftId, uint256 openPoliciesCount);
+
+    error ErrorBundleServiceBundleUnknown(NftId bundleNftId);
+    error ErrorBundleServiceBundlePoolMismatch(NftId expectedPoolNftId, NftId bundlePoolNftId);
+
+    /// @dev create a new bundle for the specified attributes
+    /// may only be called by pool service
+    function create(
+        IInstance instance, // instance relevant for bundle
+        NftId poolNftId, // the pool the bundle will be linked to
+        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 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
+    function lock(NftId bundleNftId) external;
+
+    /// @dev activates the specified bundle
+    /// only locked bundles may be unlocked
+    /// may only be called by registered and unlocked pool components
+    function unlock(NftId bundleNftId) external;
+
+    /// @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
+    /// may only be called by registered and unlocked pool components
+    function close(
+        IInstance instance, 
+        NftId bundleNftId
+    ) external;
+
+    /// @dev set bundle fee to provided value
+    /// may only be called by registered and unlocked pool components
+    function setFee(
         NftId bundleNftId,
         Fee memory fee
     ) external;
 
-    function updateBundle(NftId instanceNftId, NftId bundleNftId, IBundle.BundleInfo memory bundleInfo, StateId state) external;
 
+    /// @dev locks the specified collateral in the bundle
+    /// the locked collateral is added to the bundle locked capital
+    /// the bundles' fees are updated with the fees for this premium
+    /// the premium (minus bundle fee) is added to the bundle capital
+    /// may only be called by pool service
     function lockCollateral(
         IInstance instanceNftId, 
         NftId policyNftId, 
         NftId bundleNftId, 
         uint256 collateralAmount, 
-        uint256 netPremium
-    )
-        external
-        returns (
-            IBundle.BundleInfo memory bundleInfo
-        );
-
-    function increaseBalance(IInstance instance, NftId bundleNftId,  uint256 amount) external;
-
-    function closePolicy(IInstance instance, NftId policyNftId, NftId bundleNftId, uint256 collateralAmount) external;
+        uint256 premium // premium amount after pool fee
+    ) external;
 
-    // function fundBundle(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 defundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    /// @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
+    ) external;
 
-    function lockBundle(NftId bundleNftId) external;
+    function increaseBalance(IInstance instance, NftId bundleNftId,  uint256 amount) external;
 
-    function unlockBundle(NftId bundleNftId) external;
+    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 
-    // function closeBundle(NftId bundleNftId) external;
+    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 }