@etherisc/gif-next 0.0.2-d250c72 → 0.0.2-d2f2474-604

package/contracts/pool/IBundleService.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {NftId} from "../type/NftId.sol";
+import {Fee} from "../type/Fee.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {UFixed} from "../type/UFixed.sol";
+
+interface IBundleService is IService {
+
+    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, Amount amount);
+    error ErrorBundleServiceBundleNotOpen(NftId bundleNftId, StateId state, Timestamp expiredAt);
+    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);
+    
+    error ErrorBundleServiceUnstakeAmountExceedsLimit(Amount amount, Amount limit);
+
+    error ErrorBundleServiceExtensionLifetimeIsZero();
+
+    event LogBundleServiceBundleCreated(NftId bundleNftId, NftId poolNftId, Seconds lifetime);
+    event LogBundleServiceBundleClosed(NftId bundleNftId);
+    event LogBundleServiceBundleLocked(NftId bundleNftId);
+    event LogBundleServiceBundleUnlocked(NftId bundleNftId);
+    event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
+    event LogBundleServiceBundleFeeUpdated(NftId bundleNftId, Amount fixedFee, UFixed fractionalFee);
+    event LogBundleServiceCollateralLocked(NftId bundleNftId, NftId policyNftId, Amount collateralAmount);
+    event LogBundleServiceCollateralReleased(NftId bundleNftId, NftId policyNftId, Amount collateralAmount);
+    event LogBundleServiceBundleStaked(NftId bundleNftId, Amount amount);
+    event LogBundleServiceBundleUnstaked(NftId bundleNftId, Amount amount);
+
+    /// @dev Create a new bundle for the specified attributes.
+    function create(
+        address owner, // initial bundle owner
+        Fee memory fee, // fees deducted from premium that go to bundle owner
+        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 increase bundle stakes by the specified amount. bundle must not be expired or closed
+    /// may only be called by the pool service
+    function stake(
+        InstanceReader instanceReader,
+        InstanceStore instanceStore,
+        NftId bundleNftId, 
+        Amount amount
+    ) external;
+
+    /// @dev decrease bundle stakes by the specified amount
+    /// may only be called by the pool service
+    function unstake(InstanceStore instanceStore, NftId bundleNftId, Amount amount) external returns (Amount unstakedAmount);
+
+    /// @dev extend the lifetime of the bundle by the specified time in seconds
+    function extend(NftId bundleNftId, Seconds lifetimeExtension) external returns (Timestamp extendedExpiredAt);
+
+    /// @dev locks/unlocks the specified bundle. 
+    /// locked bundles are not available to collateralize new policies.
+    /// may only be called by registered and unlocked pool components.
+    function setLocked(NftId bundleNftId, bool locked) 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
+    /// @return balanceAmount the unstaked amount that was remaining in the bundle
+    /// @return feeAmount the fee amount that was remaining for the bundle
+    function close(
+        IInstance instance, 
+        NftId bundleNftId
+    ) external returns (Amount balanceAmount, Amount feeAmount);
+
+    /// @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;
+
+
+    /// @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 instance, 
+        NftId policyNftId, 
+        NftId bundleNftId, 
+        Amount collateralAmount
+    ) external;
+
+
+    /// @dev releases the specified collateral in the bundle
+    /// may only be called by pool service
+    function releaseCollateral(
+        InstanceStore instanceStore, 
+        NftId policyNftId, 
+        NftId bundleNftId, 
+        Amount collateralAmount
+    ) external;
+}

package/contracts/pool/IPoolComponent.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {Fee} from "../type/Fee.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {IComponents} from "../instance/module/IComponents.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
+interface IPoolComponent is IInstanceLinkedComponent {
+
+    error ErrorPoolNotBundleOwner(NftId bundleNftId, address caller);
+    error ErrorPoolNotPoolService(address caller);
+    error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
+
+    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, Amount collateralizationAmount);
+
+    /// @dev This is a callback function that is called by the product service when underwriting a policy.
+    /// The pool has the option to check the details and object to underwriting by reverting.
+    /// The function is only called for "active" pools that ask to be involved/notified.
+    /// The default implementation is empty.
+    function verifyApplication(
+        NftId applicationNftId, 
+        NftId bundleNftId, 
+        Amount collateralizationAmount
+    ) external;
+
+    /// @dev Returns true iff the application matches with the bundle.
+    /// This is a callback function that is only called if a pool declares itself as a verifying pool
+    /// The default implementation returns true.
+    function applicationMatchesBundle(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        Amount collateralizationAmount
+    )
+        external
+        view
+        returns (bool isMatching);
+
+
+    /// @dev This is a callback function that is called by the claim service when a claim is confirmed.
+    /// The pool has the option to implement custom behavirous such as triggering a reinsurance claim or blocking the claim confirmaation.
+    /// The default implementation is empty.
+    function processConfirmedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount amount
+    ) external;
+
+
+    /// @dev Returns initial pool specific infos for this pool
+    function getInitialPoolInfo() external view returns (IComponents.PoolInfo memory info);
+
+}

package/contracts/pool/IPoolService.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IInstance} from "../instance/IInstance.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+
+interface IPoolService is IService {
+
+    event LogPoolServiceMaxBalanceAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
+    event LogPoolServiceWalletFunded(NftId poolNftId, address poolOwner, Amount amount);
+    event LogPoolServiceWalletDefunded(NftId poolNftId, address poolOwner, Amount amount);
+
+    event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+    event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+
+    event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+
+    event LogPoolServiceFeesWithdrawn(NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
+
+    event LogPoolServiceProcessFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount);
+
+    event LogPoolServiceApplicationVerified(NftId poolNftId, NftId bundleNftId, NftId applicationNftId, Amount totalCollateralAmount);
+    event LogPoolServiceCollateralLocked(NftId poolNftId, NftId bundleNftId, NftId applicationNftId, Amount totalCollateralAmount, Amount lockedCollateralAmount);
+    event LogPoolServiceCollateralReleased(NftId bundleNftId, NftId policyNftId, Amount remainingCollateralAmount);
+    event LogPoolServiceSaleProcessed(NftId poolNftId, NftId bundleNftId, Amount bundleNetAmount, Amount bundleFeeAmount, Amount poolFeeAmount);
+    event LogPoolServicePayoutProcessed(NftId poolNftId, NftId bundleNftId, NftId policyNftId, PayoutId payoutId, Amount netPayoutAmount, Amount processingFeeAmount, address payoutBeneficiary);
+
+    error ErrorPoolServicePoolNotExternallyManaged(NftId poolNftId);
+    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 ErrorPoolServiceMaxBalanceAmountExceeded(NftId poolNftId, Amount maxBalanceAmount, Amount currentBalanceAmount, Amount transferAmount);
+    error ErrorPoolServiceFeesWithdrawAmountExceedsLimit(Amount amount, Amount limit);
+
+    /// @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
+    /// - 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, 
+        address token,
+        NftId productNftId,
+        NftId applicationNftId,
+        NftId bundleNftId,
+        Amount sumInsuredAmount // premium amount after product and distribution fees
+    )
+        external
+        returns (
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        );
+
+
+    /// @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 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 processPayout(
+        InstanceReader instanceReader,
+        InstanceStore instanceStore, 
+        NftId productNftId,
+        NftId policyNftId, 
+        NftId bundleNftId,
+        PayoutId payoutId,
+        Amount payoutAmount,
+        address payoutBeneficiary
+    ) external returns (Amount netPayoutAmount, Amount processingFeeAmount);
+
+
+    /// @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
+    /// 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 Withdraw bundle feeds for the specified bundle.
+    function withdrawBundleFees(NftId bundleNftId, Amount amount) external returns (Amount withdrawnAmount);
+
+
+    /// @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 Fund the pool wallet with the provided amount.
+    /// This function will collect the amount from the pool owner 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(Amount amount) external;
+
+
+    /// @dev Defund the specified pool wallet with the provided amount.
+    /// This function will transfer the amount from the pool wallet to the pool owner.
+    /// The function will not update balance amounts managed by the framework.
+    /// Only available for externally managed pools.
+    function defundPoolWallet(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, 
+    //     Amount sumInsuredAmount
+    // )
+    //     external
+    //     view 
+    //     returns(
+    //         NftId poolNftId,
+    //         Amount totalCollateralAmount,
+    //         Amount localCollateralAmount,
+    //         bool poolIsVerifyingApplications
+    //     );
+
+
+    // /// @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, 
+    //     Amount sumInsuredAmount
+    // )
+    //     external
+    //     pure 
+    //     returns(
+    //         Amount totalCollateralAmount,
+    //         Amount localCollateralAmount
+    //     );
+
+}

package/contracts/pool/Pool.sol

@@ -0,0 +1,333 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount, AmountLib} from "../type/Amount.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";
+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 {InstanceReader} from "../instance/InstanceReader.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 {UFixed} from "../type/UFixed.sol";
+
+abstract contract Pool is
+    InstanceLinkedComponent, 
+    IPoolComponent 
+{
+    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.Pool")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant POOL_STORAGE_LOCATION_V1 = 0x25e3e51823fbfffb988e0a2744bb93722d9f3e906c07cc0a9e77884c46c58300;
+
+    struct PoolStorage {
+        IComponents.PoolInfo _poolInfo;
+        IComponentService _componentService;
+        IPoolService _poolService;
+        IBundleService _bundleService;
+    }
+
+
+    modifier onlyBundleOwner(NftId bundleNftId) {
+        if(msg.sender != getRegistry().ownerOf(bundleNftId)) {
+            revert ErrorPoolNotBundleOwner(bundleNftId, msg.sender);
+        }
+        _;
+    }
+
+
+    // TODO remove function once this is no longer used to produce contract locations on the fly ...
+    function getContractLocation(bytes memory name) external pure returns (bytes32 hash) {
+        return keccak256(abi.encode(uint256(keccak256(name)) - 1)) & ~bytes32(uint256(0xff));
+    }
+
+
+    /// @dev see {IPoolComponent.verifyApplication}
+    function verifyApplication(
+        NftId applicationNftId, 
+        NftId bundleNftId, 
+        Amount collateralizationAmount
+    )
+        public
+        virtual
+        restricted()
+        onlyNftOfType(applicationNftId, POLICY())
+    {
+        InstanceReader reader = _getInstanceReader();
+        if(!applicationMatchesBundle(
+            applicationNftId,
+            reader.getPolicyInfo(applicationNftId).applicationData, 
+            bundleNftId, 
+            reader.getBundleInfo(bundleNftId).filter,
+            collateralizationAmount)
+        )
+        {
+            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
+        }
+
+        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
+    }
+
+
+    /// @dev see {IPoolComponent.processConfirmedClaim}
+    function processConfirmedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+        onlyNftOfType(policyNftId, POLICY())
+    {
+        // default implementation is empty
+    }
+
+
+    /// @dev see {IPoolComponent.applicationMatchesBundle}
+    /// Default implementation always returns true.
+    /// Override this function to implement any custom application verification.
+    /// Calling super.applicationMatchesBundle will ensure validation of application and bundle nft ids.
+    function applicationMatchesBundle(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        Amount collateralizationAmount
+    )
+        public
+        virtual
+        view
+        onlyNftOfType(applicationNftId, POLICY())
+        onlyNftOfType(bundleNftId, BUNDLE())
+        returns (bool isMatching)
+    {
+        return true;
+    }
+
+
+    function getInitialPoolInfo()
+        public 
+        virtual 
+        view 
+        returns (IComponents.PoolInfo memory poolInfo)
+    {
+        return _getPoolStorage()._poolInfo;
+    }
+
+    // Internals
+
+    function __Pool_init(
+        address registry,
+        NftId productNftId,
+        string memory name,
+        IComponents.PoolInfo memory poolInfo,
+        IAuthorization authorization,
+        address initialOwner,
+        bytes memory componentData // component specifidc data 
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        __InstanceLinkedComponent_init(
+            registry, 
+            productNftId,  
+            name, 
+            POOL(), 
+            authorization, 
+            poolInfo.isInterceptingBundleTransfers, 
+            initialOwner, 
+            componentData);
+
+        PoolStorage storage $ = _getPoolStorage();
+
+        $._poolInfo = poolInfo;
+        $._poolService = IPoolService(_getServiceAddress(POOL())); 
+        $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        _registerInterface(type(IPoolComponent).interfaceId);
+    }
+
+
+    /// @dev Update pool fees to the specified values.
+    /// Pool fee: are deducted from the premium amount and goes to the pool owner.
+    /// Staking fee: are deducted from the staked tokens by a bundle owner and goes to the pool owner.
+    /// Performance fee: when a bundle is closed a bundle specific profit is calculated.
+    /// The performance fee is deducted from this profit and goes to the pool owner.
+    function _setPoolFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        internal
+        virtual
+    {
+        _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
+    }
+
+
+    /// @dev Sets the maximum balance amound held by this pool.
+    /// Function may only be called by pool owner.
+    function _setMaxBalanceAmount(Amount maxBalanceAmount)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
+    }
+
+
+    /// @dev Fund the pool wallet with the specified amount.
+    /// Function is only available for externally managed pools.
+    function _fundPoolWallet(Amount amount)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.fundPoolWallet(amount);
+    }
+
+
+    /// @dev Withdraw the specified amount from the pool wallet.
+    /// Function is only available for externally managed pools.
+    function _defundPoolWallet(Amount amount)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.defundPoolWallet(amount);
+    }
+
+
+    /// @dev Creates a new empty bundle using the provided parameter values.
+    function _createBundle(
+        address bundleOwner,
+        Fee memory fee,
+        Seconds lifetime, 
+        bytes memory filter
+    )
+        internal
+        returns(NftId bundleNftId)
+    {
+        bundleNftId = _getPoolStorage()._bundleService.create(
+            bundleOwner,
+            fee,
+            lifetime,
+            filter);
+
+        // TODO add logging
+    }
+
+
+    /// @dev Sets the fee for the specified bundle.
+    /// The fee is added on top of the poolFee and deducted from the premium amounts
+    /// Via these fees individual bundler owner may earn income per policy in the context of peer to peer pools.
+    function _setBundleFee(
+        NftId bundleNftId, 
+        Fee memory fee
+    )
+        internal
+        virtual
+    {
+        _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
+    }
+
+
+    /// @dev increases the staked tokens by the specified amount
+    /// bundle MUST be in active or locked state
+    function _stake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        internal
+        virtual
+        returns(Amount) 
+    {
+        return _getPoolStorage()._poolService.stake(bundleNftId, amount);
+    }
+
+
+    /// @dev decreases the staked tokens by the specified amount
+    /// bundle MUST be in active, locked or closed state
+    function _unstake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        internal
+        virtual
+        returns(Amount netAmount) 
+    {
+        return _getPoolStorage()._poolService.unstake(bundleNftId, amount);
+    }
+
+
+    /// @dev extends the bundle lifetime of the bundle by the specified time
+    /// bundle MUST be in active or locked state
+    function _extend(
+        NftId bundleNftId, 
+        Seconds lifetimeExtension
+    )
+        internal
+        virtual
+        returns (Timestamp extendedExpiredAt) 
+    {
+        return _getPoolStorage()._bundleService.extend(bundleNftId, lifetimeExtension);
+    }
+
+
+    /// @dev Locks the specified bundle.
+    /// A bundle to be locked MUST be in active state.
+    /// Locked bundles may not be used to collateralize any new policy.
+    function _setBundleLocked(NftId bundleNftId, bool locked)
+        internal
+        virtual
+    {
+        _getPoolStorage()._bundleService.setLocked(bundleNftId, locked);
+    }
+
+
+    /// @dev Close the specified bundle.
+    /// A bundle to be closed MUST be in active or locked state.
+    /// 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 _closeBundle(NftId bundleNftId)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.closeBundle(bundleNftId);
+    }
+
+
+    /// @dev Withdraws the specified amount of fees from the bundle.
+    function _withdrawBundleFees(NftId bundleNftId, Amount amount) 
+        internal
+        returns (Amount withdrawnAmount) 
+    {
+        return _getPoolStorage()._poolService.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
+        }
+    }
+}