@etherisc/gif-next 0.0.2-ffa91a6-022 → 3.0.0-0fefe0d-162

package/contracts/oracle/BasicOracle.sol

@@ -34,12 +34,11 @@ contract BasicOracle is
         onlyInitializing()
     {
 
-        _initializeOracle(
+        __Oracle_init(
             registry,
             instanceNftId,
             authorization,
             initialOwner,
-            name,
-            "");
+            name);
     }
 }

package/contracts/oracle/BasicOracleAuthorization.sol

@@ -14,10 +14,26 @@ contract BasicOracleAuthorization
      is Authorization
 {
 
-     constructor(string memory componentName)
-          Authorization(componentName, ORACLE(), true, false)
+     constructor(
+          string memory componentName,
+          string memory commitHash
+     )
+          Authorization(
+               componentName, 
+               ORACLE(), 
+               3, 
+               commitHash, 
+               TargetType.Component, 
+               false)
      {}
 
+     function _setupServiceTargets()
+          internal
+          virtual override
+     {
+          _authorizeServiceDomain(ORACLE(), address(15));
+     }
+
      function _setupTargetAuthorizations()
           internal
           virtual override

package/contracts/oracle/IOracle.sol

@@ -9,14 +9,19 @@ import {Timestamp} from "../type/Timestamp.sol";
 interface IOracle {
 
     struct RequestInfo {
+        // slot 0
         NftId requesterNftId; // originator of the request
-        string callbackMethodName; // callback function of the requestor to call to provide response data
         NftId oracleNftId; // responsible oracle component
-        bytes requestData; 
-        bytes responseData; 
+        bool isCancelled;
         Timestamp respondedAt; // response timestamp
+        // slot 1
         Timestamp expiredAt; // expiry timestamp
-        bool isCancelled;
+        // slot 2
+        string callbackMethodName; // callback function of the requestor to call to provide response data
+        // slot 3
+        bytes requestData; 
+        // slot 4
+        bytes responseData; 
     }
 
 

package/contracts/oracle/IOracleService.sol

@@ -41,26 +41,26 @@ interface IOracleService is IService {
         string calldata callbackMethodName
     ) external returns (RequestId requestId);
 
-    /// @dev respond to oracle request by oracle compnent.
-    /// the response data is amende in the request info stored with the instance.
-    /// the request state changes to FULFILLED (when calling the callback method of the requester is successful)
+    /// @dev Respond to oracle request by oracle compnent.
+    /// The response data is amended in the request info stored with the instance.
+    /// The request state changes to FULFILLED (when calling the callback method of the requester is successful)
     /// or to FAILED when calling the requester is not succesful.
-    /// the function returns true iff the state changes to FULFILLED.
-    /// permissioned: only the oracle component linked to the request id may call this method
+    /// The function returns true iff the state changes to FULFILLED.
+    /// Permissioned: only the receiving oracle component may call this method
     function respond(
         RequestId requestId,
         bytes calldata responseData
     ) external returns (bool success);
 
-    /// @dev re send a failed response to the requester.
-    /// only requests in state FAILED may be re sent.
-    /// the request state changes to FULFILLED when calling the callback method of the requester is successful.
-    /// permissioned: only the requester may resend a request
+    /// @dev Resend a failed response to the requester.
+    /// Only requests in state FAILED may be resent.
+    /// The request state changes to FULFILLED when calling the callback method of the requester is successful.
+    /// Permissioned: only the receiving oracle may resend a request
     function resend(RequestId requestId) external;
 
-    /// @dev notify the oracle component that the specified request has become invalid.
-    /// only requests in state ACTIVE may be cancelled.
-    /// permissioned: only the requester may cancel a request
+    /// @dev Notify the oracle component that the specified request has become invalid.
+    /// Only requests in state ACTIVE may be cancelled.
+    /// Permissioned: only the requester may cancel a request
     function cancel(RequestId requestId) external;
 
 }

package/contracts/oracle/Oracle.sol

@@ -75,27 +75,25 @@ abstract contract Oracle is
     }
 
 
-    function _initializeOracle(
+    function __Oracle_init(
         address registry,
         NftId productNftId,
         IAuthorization authorization,
         address initialOwner,
-        string memory name,
-        bytes memory componentData // component specifidc data 
+        string memory name
     )
         internal
         virtual
         onlyInitializing()
     {
-        _initializeInstanceLinkedComponent(
+        __InstanceLinkedComponent_init(
             registry, 
             productNftId, 
             name, 
             ORACLE(), 
             authorization,
             true, 
-            initialOwner, 
-            componentData);
+            initialOwner);
 
         OracleStorage storage $ = _getOracleStorage();
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 

package/contracts/oracle/OracleService.sol

@@ -48,7 +48,7 @@ contract OracleService is
     )
         external 
         virtual 
-        // restricted() // add authz
+        restricted()
         onlyNftOfType(oracleNftId, ORACLE())
         returns (RequestId requestId) 
     {
@@ -104,7 +104,7 @@ contract OracleService is
     )
         external
         virtual
-        // restricted() // add authz
+        restricted()
         returns (bool success)
     {
         (
@@ -118,7 +118,7 @@ contract OracleService is
         bool callerIsOracle = true;
         IOracle.RequestInfo memory request = _checkAndGetRequestInfo(instance, requestId, oracleNftId, callerIsOracle);
         request.responseData = responseData;
-        request.respondedAt = TimestampLib.blockTimestamp();
+        request.respondedAt = TimestampLib.current();
 
         instance.getInstanceStore().updateRequest(
             requestId, request, KEEP_STATE());
@@ -153,7 +153,7 @@ contract OracleService is
     function resend(RequestId requestId)
         external 
         virtual 
-        // restricted() // add authz
+        restricted()
     {
         (
             IRegistry.ObjectInfo memory info, 
@@ -192,7 +192,7 @@ contract OracleService is
     function cancel(RequestId requestId)
         external 
         virtual 
-        // restricted() // add authz
+        restricted()
     {
         (
             IRegistry.ObjectInfo memory info, 
@@ -253,8 +253,8 @@ contract OracleService is
         }
 
         // check expiriyAt >= now
-        if (expiryAt < TimestampLib.blockTimestamp()) {
-            revert ErrorOracleServiceExpiryInThePast(TimestampLib.blockTimestamp(), expiryAt);
+        if (expiryAt < TimestampLib.current()) {
+            revert ErrorOracleServiceExpiryInThePast(TimestampLib.current(), expiryAt);
         }
 
         // check callbackMethodName.length > 0
@@ -298,7 +298,7 @@ contract OracleService is
         }
 
         // check expiry
-        if (info.expiredAt < TimestampLib.blockTimestamp()) {
+        if (info.expiredAt < TimestampLib.current()) {
             revert ErrorOracleServiceRequestExpired(requestId, info.expiredAt);
         }
     }

package/contracts/pool/BasicPool.sol

@@ -29,14 +29,13 @@ abstract contract BasicPool is
         virtual
         onlyInitializing()
     {
-        _initializePool(
+        __Pool_init(
             registry, 
             productNftId, 
             name, 
             poolInfo, 
             authorization,
-            initialOwner, 
-            ""); // componentData
+            initialOwner);
     }
 
     function stake(
@@ -82,25 +81,14 @@ abstract contract BasicPool is
     }
 
 
-    function lockBundle(NftId bundleNftId)
+    function setBundleLocked(NftId bundleNftId, bool locked)
         public
         virtual
         restricted()
         onlyBundleOwner(bundleNftId)
         onlyNftOfType(bundleNftId, BUNDLE())
     {
-        _lockBundle(bundleNftId);
-    }
-
-
-    function unlockBundle(NftId bundleNftId)
-        public
-        virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
-        onlyNftOfType(bundleNftId, BUNDLE())
-    {
-        _unlockBundle(bundleNftId);
+        _setBundleLocked(bundleNftId, locked);
     }
 
 

package/contracts/pool/BasicPoolAuthorization.sol

@@ -18,15 +18,21 @@ contract BasicPoolAuthorization
 {
 
      constructor(string memory poolName)
-          Authorization(poolName, POOL(), true, true)
+          Authorization(
+               poolName, 
+               POOL(), 
+               3,
+               COMMIT_HASH,
+               TargetType.Component, 
+               true)
      {}
 
      function _setupServiceTargets()
           internal
           virtual override
      {
-          _addServiceTargetWithRole(COMPONENT());
-          _addServiceTargetWithRole(POOL());
+          _authorizeServiceDomain(COMPONENT(), address(11));
+          _authorizeServiceDomain(POOL(), address(12));
      }
 
      function _setupTokenHandlerAuthorizations() internal virtual override {
@@ -54,8 +60,7 @@ contract BasicPoolAuthorization
           _authorize(functions, BasicPool.stake.selector, "stake");
           _authorize(functions, BasicPool.unstake.selector, "unstake");
           _authorize(functions, BasicPool.extend.selector, "extend");
-          _authorize(functions, BasicPool.lockBundle.selector, "lockBundle");
-          _authorize(functions, BasicPool.unlockBundle.selector, "unlockBundle");
+          _authorize(functions, BasicPool.setBundleLocked.selector, "setBundleLocked");
           _authorize(functions, BasicPool.closeBundle.selector, "closeBundle");
           _authorize(functions, BasicPool.setBundleFee.selector, "setBundleFee");
 

package/contracts/pool/BundleService.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.20;
 import {IAccountingService} from "../accounting/IAccountingService.sol";
 import {IBundle} from "../instance/module/IBundle.sol";
 import {IBundleService} from "./IBundleService.sol";
-import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
@@ -13,19 +12,19 @@ import {InstanceStore} from "../instance/InstanceStore.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {BundleSet} from "../instance/BundleSet.sol";
-import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
 import {Fee} from "../type/Fee.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {ObjectType, ACCOUNTING, COMPONENT, POOL, BUNDLE, POLICY, REGISTRY} from "../type/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../type/StateId.sol";
+import {PoolLib} from "./PoolLib.sol";
 import {Seconds} from "../type/Seconds.sol";
+import {Service} from "../shared/Service.sol";
+import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../type/StateId.sol";
 import {Timestamp, TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
 
-string constant BUNDLE_SERVICE_NAME = "BundleService";
 
 contract BundleService is 
-    ComponentVerifyingService, 
+    Service, 
     IBundleService 
 {
     
@@ -69,7 +68,7 @@ contract BundleService is
     {
         _checkNftType(bundleNftId, BUNDLE());
 
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (NftId poolNftId, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
         InstanceReader instanceReader = instance.getInstanceReader();
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
         if(bundleInfo.poolNftId.eqz()) {
@@ -82,6 +81,8 @@ contract BundleService is
 
         bundleInfo.fee = fee;
         instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
+
+        emit LogBundleServiceBundleFeeUpdated(bundleNftId, fee.fixedFee, fee.fractionalFee);
     }
 
 
@@ -96,7 +97,7 @@ contract BundleService is
         restricted()
         returns(NftId bundleNftId)
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (NftId poolNftId, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
 
         // register bundle with registry
         bundleNftId = _registryService.registerBundle(
@@ -119,8 +120,8 @@ contract BundleService is
                 poolNftId: poolNftId,
                 fee: bundleFee,
                 filter: filter,
-                activatedAt: TimestampLib.blockTimestamp(),
-                expiredAt: TimestampLib.blockTimestamp().addSeconds(lifetime),
+                activatedAt: TimestampLib.current(),
+                expiredAt: TimestampLib.current().addSeconds(lifetime),
                 closedAt: zeroTimestamp()
             })
         );
@@ -129,7 +130,7 @@ contract BundleService is
         BundleSet bundleManager = instance.getBundleSet();
         bundleManager.add(bundleNftId);
 
-        emit LogBundleServiceBundleCreated(bundleNftId, poolNftId);
+        emit LogBundleServiceBundleCreated(bundleNftId, poolNftId, lifetime);
     }
 
 
@@ -155,7 +156,7 @@ contract BundleService is
             IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
 
             // ensure bundle is active and not yet expired
-            if(bundleState != ACTIVE() || bundleInfo.expiredAt < TimestampLib.blockTimestamp()) {
+            if(bundleState != ACTIVE() || bundleInfo.expiredAt < TimestampLib.current()) {
                 revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
             }
         }
@@ -179,32 +180,12 @@ contract BundleService is
         // effects
         // updated locked amount
         instanceStore.increaseLocked(bundleNftId, collateralAmount);
-    }
-
-
-    function lock(NftId bundleNftId) 
-        external
-        virtual
-        restricted()
-    {
-        // checks
-        _checkNftType(bundleNftId, BUNDLE());
-
-        (,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-
-        // udpate bundle state
-        instance.getInstanceStore().updateBundleState(bundleNftId, PAUSED());
 
-        // effects
-        // update set of active bundles
-        BundleSet bundleManager = instance.getBundleSet();
-        bundleManager.lock(bundleNftId);
-
-        emit LogBundleServiceBundleLocked(bundleNftId);
+        emit LogBundleServiceCollateralLocked(bundleNftId, policyNftId, collateralAmount);
     }
 
 
-    function unlock(NftId bundleNftId) 
+    function setLocked(NftId bundleNftId, bool locked) 
         external
         virtual
         restricted()
@@ -212,19 +193,21 @@ contract BundleService is
         // checks
         _checkNftType(bundleNftId, BUNDLE());
 
-        (,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
 
         // effects
-        // udpate bundle state
-        instance.getInstanceStore().updateBundleState(bundleNftId, ACTIVE());
-
         // update set of active bundles
         BundleSet bundleManager = instance.getBundleSet();
-        bundleManager.unlock(bundleNftId);
 
-        emit LogBundleServiceBundleActivated(bundleNftId);
+        if (locked) {
+            bundleManager.lock(bundleNftId);
+            emit LogBundleServiceBundleLocked(bundleNftId);
+        } else {
+            bundleManager.unlock(bundleNftId);
+            emit LogBundleServiceBundleUnlocked(bundleNftId);
+        }
     }
-
+    
 
     function close(
         IInstance instance,
@@ -260,6 +243,8 @@ contract BundleService is
             unstakedAmount = balanceAmountWithFees - feeAmount;
             _accountingService.decreaseBundleBalance(instanceStore, bundleNftId, unstakedAmount, feeAmount);
         }
+
+        emit LogBundleServiceBundleClosed(bundleNftId);
     }
 
     /// @inheritdoc IBundleService
@@ -280,7 +265,7 @@ contract BundleService is
         StateId bundleState = instanceReader.getBundleState(bundleNftId);
 
         if( (bundleState != ACTIVE() && bundleState != PAUSED()) // locked bundles can be staked
-            || bundleInfo.expiredAt < TimestampLib.blockTimestamp() 
+            || bundleInfo.expiredAt < TimestampLib.current() 
             || bundleInfo.closedAt.gtz()) {
             revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
         }
@@ -291,6 +276,8 @@ contract BundleService is
             bundleNftId, 
             amount, 
             AmountLib.zero());
+
+        emit LogBundleServiceBundleStaked(bundleNftId, amount);
     }
 
     /// @inheritdoc IBundleService
@@ -332,6 +319,8 @@ contract BundleService is
             bundleNftId, 
             unstakedAmount, 
             AmountLib.zero());
+        
+        emit LogBundleServiceBundleUnstaked(bundleNftId, unstakedAmount);
     }
 
     /// @inheritdoc IBundleService
@@ -344,7 +333,7 @@ contract BundleService is
         // checks
         _checkNftType(bundleNftId, BUNDLE());
 
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (NftId poolNftId, IInstance instance) = PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
         IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
         StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
 
@@ -354,7 +343,7 @@ contract BundleService is
         }
 
         // ensure bundle is active and not yet expired
-        if(bundleState != ACTIVE() || bundleInfo.expiredAt < TimestampLib.blockTimestamp()) {
+        if(bundleState != ACTIVE() || bundleInfo.expiredAt < TimestampLib.current()) {
             revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
         }
 
@@ -386,6 +375,8 @@ contract BundleService is
         _checkNftType(bundleNftId, BUNDLE());
 
         instanceStore.decreaseLocked(bundleNftId, collateralAmount);
+
+        emit LogBundleServiceCollateralReleased(bundleNftId, policyNftId, collateralAmount);
     }
 
 

package/contracts/pool/IBundleService.sol

@@ -12,13 +12,10 @@ 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 {
 
-    event LogBundleServiceBundleCreated(NftId bundleNftId, NftId poolNftId);
-    event LogBundleServiceBundleActivated(NftId bundleNftId);
-    event LogBundleServiceBundleLocked(NftId bundleNftId);
-
     error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, Amount amount);
     error ErrorBundleServiceBundleNotOpen(NftId bundleNftId, StateId state, Timestamp expiredAt);
     error ErrorBundleServiceCapacityInsufficient(NftId bundleNftId, Amount capacityAmount, Amount collateralAmount);
@@ -33,7 +30,16 @@ interface IBundleService is IService {
 
     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(
@@ -62,15 +68,10 @@ interface IBundleService is IService {
     /// @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 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 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

package/contracts/pool/IPoolService.sol

@@ -11,7 +11,6 @@ import {InstanceReader} from "../instance/InstanceReader.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
 import {NftId} from "../type/NftId.sol";
 import {PayoutId} from "../type/PayoutId.sol";
-import {UFixed} from "../type/UFixed.sol";
 
 interface IPoolService is IService {
 
@@ -29,6 +28,12 @@ interface IPoolService is IService {
 
     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);
@@ -81,7 +86,7 @@ interface IPoolService is IService {
         PayoutId payoutId,
         Amount payoutAmount,
         address payoutBeneficiary
-    ) external;
+    ) external returns (Amount netPayoutAmount, Amount processingFeeAmount);
 
 
     /// @dev increase stakes for bundle

package/contracts/pool/Pool.sol

@@ -123,28 +123,26 @@ abstract contract Pool is
 
     // Internals
 
-    function _initializePool(
+    function __Pool_init(
         address registry,
         NftId productNftId,
         string memory name,
         IComponents.PoolInfo memory poolInfo,
         IAuthorization authorization,
-        address initialOwner,
-        bytes memory componentData // component specifidc data 
+        address initialOwner
     )
         internal
         virtual
         onlyInitializing()
     {
-        _initializeInstanceLinkedComponent(
+        __InstanceLinkedComponent_init(
             registry, 
             productNftId,  
             name, 
             POOL(), 
             authorization, 
             poolInfo.isInterceptingBundleTransfers, 
-            initialOwner, 
-            componentData);
+            initialOwner);
 
         PoolStorage storage $ = _getPoolStorage();
 
@@ -283,21 +281,11 @@ abstract contract Pool is
     /// @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 _lockBundle(NftId bundleNftId)
+    function _setBundleLocked(NftId bundleNftId, bool locked)
         internal
         virtual
     {
-        _getPoolStorage()._bundleService.lock(bundleNftId);
-    }
-
-
-    /// @dev Unlocks the specified bundle.
-    /// A bundle to be unlocked MUST be in locked state.
-    function _unlockBundle(NftId bundleNftId)
-        internal
-        virtual
-    {
-        _getPoolStorage()._bundleService.unlock(bundleNftId);
+        _getPoolStorage()._bundleService.setLocked(bundleNftId, locked);
     }