@etherisc/gif-next 0.0.2-f752d2a-551 → 0.0.2-f79a517-071

package/contracts/instance/Instance.sol

@@ -2,12 +2,13 @@
 pragma solidity ^0.8.19;
 
 import {NftId} from "../types/NftId.sol";
+import {INftOwnable} from "../shared/INftOwnable.sol";
+import {NftOwnable} from "../shared/NftOwnable.sol";
 import {RoleId} from "../types/RoleId.sol";
 
 import {InstanceBase} from "./base/InstanceBase.sol";
-import {AccessModule} from "./module/access/Access.sol";
-import {CompensationModule} from "./module/compensation/CompensationModule.sol";
 import {ComponentModule} from "./module/component/ComponentModule.sol";
+import {DistributionModule} from "./module/distribution/DistributionModule.sol";
 import {PolicyModule} from "./module/policy/PolicyModule.sol";
 import {PoolModule} from "./module/pool/PoolModule.sol";
 import {RiskModule} from "./module/risk/RiskModule.sol";
@@ -16,14 +17,15 @@ import {TreasuryModule} from "./module/treasury/TreasuryModule.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {Registerable} from "../shared/Registerable.sol";
-import {IAccessModule} from "./module/access/IAccess.sol";
 import {IBundleModule} from "./module/bundle/IBundle.sol";
 import {IComponentModule} from "./module/component/IComponent.sol";
 import {IPoolModule} from "./module/pool/IPoolModule.sol";
 import {IPolicyModule} from "./module/policy/IPolicy.sol";
 import {IInstanceBase} from "./base/IInstanceBase.sol";
+import {ITreasuryModule} from "./module/treasury/ITreasury.sol";
 
 import {IComponentOwnerService} from "./service/IComponentOwnerService.sol";
+import {IDistributionService} from "./service/IDistributionService.sol";
 import {IProductService} from "./service/IProductService.sol";
 import {IPoolService} from "./service/IPoolService.sol";
 
@@ -31,10 +33,9 @@ import {IKeyValueStore} from "./base/IKeyValueStore.sol";
 
 contract Instance is
     InstanceBase,
-    AccessModule,
     BundleModule,
     ComponentModule,
-    CompensationModule,
+    DistributionModule,
     PolicyModule,
     PoolModule,
     RiskModule,
@@ -42,27 +43,41 @@ contract Instance is
 {
     constructor(
         address registry,
-        NftId registryNftId
+        NftId registryNftId,
+        address initialOwner
     )
-        InstanceBase(registry, registryNftId)
-        AccessModule()
+        InstanceBase(registry, registryNftId, initialOwner)
         BundleModule()
+        DistributionModule()
         ComponentModule()
         PolicyModule()
         PoolModule()
         TreasuryModule()
     {
         initializeBundleModule(_keyValueStore);
+        initializeComponentModule(_keyValueStore);
+        initializeDistributionModule(_keyValueStore);
+        initializePolicyModule(_keyValueStore);
+        initializePoolModule(_keyValueStore);
+        initializeRiskModule(_keyValueStore);
     }
 
-    function getRegistry() public view override (Registerable, IBundleModule, IComponentModule, IPolicyModule) returns (IRegistry registry) { return super.getRegistry(); }
-    function getKeyValueStore() public view override (InstanceBase, IBundleModule) returns (IKeyValueStore keyValueStore) { return super.getKeyValueStore(); }
+    modifier onlyComponentOwnerService() override (ComponentModule, PoolModule, TreasuryModule) {
+        require(
+            msg.sender == address(this.getComponentOwnerService()),
+            "ERROR:CMP-001:NOT_REGISTRY_SERVICE"
+        );
+        _;
+    }
+
+    function getRegistry() public view override (INftOwnable, NftOwnable) returns (IRegistry registry) { return super.getRegistry(); }
 
-    function hasRole(RoleId role, address member) public view override (AccessModule, IComponentModule) returns (bool) { return super.hasRole(role, member); }
+    function getKeyValueStore() public view override (InstanceBase) returns (IKeyValueStore keyValueStore) { return super.getKeyValueStore(); }
 
-    function getComponentOwnerService() external view override (IComponentModule, IInstanceBase) returns(IComponentOwnerService service) { return _componentOwnerService; }
+    function getComponentOwnerService() external view override (IInstanceBase, IComponentModule, ITreasuryModule, IPoolModule) returns(IComponentOwnerService service) { return _componentOwnerService; }
+    function getDistributionService() external view override (IInstanceBase) returns(IDistributionService service) { return _distributionService; }
     function getProductService() external view override (IBundleModule, IPolicyModule, IInstanceBase) returns(IProductService service) { return _productService; }
     function getPoolService() external view override (IBundleModule, IPoolModule, IInstanceBase) returns(IPoolService service) { return _poolService; }
 
-    function getOwner() public view override (IAccessModule, Registerable) returns(address owner) { return super.getOwner(); }
+    function getOwner() public view override (INftOwnable, NftOwnable) returns(address owner) { return super.getOwner(); }
 }

package/contracts/instance/base/ComponentServiceBase.sol

@@ -2,21 +2,23 @@
 pragma solidity ^0.8.19;
 
 import {IRegistry} from "../../registry/IRegistry.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
 import {IInstance} from "../../instance/IInstance.sol";
 import {ObjectType, INSTANCE, PRODUCT, POOL} from "../../types/ObjectType.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
 import {ServiceBase} from "./ServiceBase.sol";
+import {Version, VersionPart, VersionLib} from "../../types/Version.sol";
 
 abstract contract ComponentServiceBase is ServiceBase {
 
     constructor(
         address registry,
-        NftId registryNftId
+        NftId registryNftId,
+        address initialOwner
     )
-        ServiceBase(registry, registryNftId)
-    // solhint-disable-next-line no-empty-blocks
     {
+        _initializeServiceBase(registry, registryNftId, initialOwner);
     }
 
 
@@ -30,13 +32,18 @@ abstract contract ComponentServiceBase is ServiceBase {
             IInstance instance
         )
     {
-        NftId componentNftId = _registry.getNftId(msg.sender);
+        NftId componentNftId = getRegistry().getNftId(msg.sender);
         require(componentNftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
 
-        info = _registry.getObjectInfo(componentNftId);
+        info = getRegistry().getObjectInfo(componentNftId);
         require(info.objectType == objectType, "OBJECT_TYPE_INVALID");
 
-        address instanceAddress = _registry.getObjectInfo(info.parentNftId).objectAddress;
+        address instanceAddress = getRegistry().getObjectInfo(info.parentNftId).objectAddress;
         instance = IInstance(instanceAddress);
     }
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        address service = getRegistry().getServiceAddress("RegistryService", getMajorVersion());
+        return IRegistryService(service);
+    }
 }

package/contracts/instance/base/IInstanceBase.sol

@@ -1,14 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
+
+import {Key32} from "../../types/Key32.sol";
+import {StateId} from "../../types/StateId.sol";
 
 import {IKeyValueStore} from "./IKeyValueStore.sol";
+
 import {IComponentOwnerService} from "../service/IComponentOwnerService.sol";
+import {IDistributionService} from "../service/IDistributionService.sol";
 import {IProductService} from "../service/IProductService.sol";
 import {IPoolService} from "../service/IPoolService.sol";
 
 interface IInstanceBase {
     function getKeyValueStore() external view returns (IKeyValueStore keyValueStore);
-    function getComponentOwnerService() external view returns(IComponentOwnerService service);
+    function updateState(Key32 key, StateId state) external;
+    function getState(Key32 key) external view returns (StateId state);
+
+    function getComponentOwnerService() external view returns(IComponentOwnerService);
+    function getDistributionService() external view returns(IDistributionService);
     function getProductService() external view returns(IProductService service);
     function getPoolService() external view returns(IPoolService service);
 }

package/contracts/instance/base/IKeyValueStore.sol

@@ -29,9 +29,9 @@ interface IKeyValueStore is ILifecycle {
         Blocknumber createdIn;
     }
 
-    event LogInfoCreated(Key key, StateId state, address createdBy);
-    event LogInfoUpdated(Key key, StateId state, address updatedBy, Blocknumber lastUpdatedIn);
-    event LogStateUpdated(Key key, StateId stateOld, StateId stateNew, address updatedBy, Blocknumber lastUpdatedIn);
+    event LogInfoCreated(Key key, StateId state, address createdBy, address txOrigin);
+    event LogInfoUpdated(Key key, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogStateUpdated(Key key, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
 
     // generic state changing functions
     function create(Key32 key, ObjectType objectType, bytes memory data) external;
@@ -46,4 +46,5 @@ interface IKeyValueStore is ILifecycle {
     function getState(Key32 key) external view returns (StateId state);
 
     function toKey32(ObjectType objectType, KeyId id) external pure returns(Key32);
+    function toKey(Key32 key32) external pure returns(Key memory key);
 }

package/contracts/instance/base/InstanceBase.sol

@@ -1,16 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Versionable} from "../../shared/Versionable.sol";
 import {Registerable} from "../../shared/Registerable.sol";
-// import {IRegistry} from "../registry/IRegistry.sol";
 
-// import {IInstance} from "./IInstance.sol";
 import {ObjectType, INSTANCE} from "../../types/ObjectType.sol";
+import {Key32} from "../../types/Key32.sol";
 import {NftId} from "../../types/NftId.sol";
+import {StateId} from "../../types/StateId.sol";
 import {Version, VersionPart, VersionLib} from "../../types/Version.sol";
 
 import {IComponentOwnerService} from "../service/IComponentOwnerService.sol";
+import {IDistributionService} from "../service/IDistributionService.sol";
 import {IProductService} from "../service/IProductService.sol";
 import {IPoolService} from "../service/IPoolService.sol";
 
@@ -28,16 +29,19 @@ abstract contract InstanceBase is
     IKeyValueStore internal _keyValueStore;
 
     IComponentOwnerService internal _componentOwnerService;
+    IDistributionService internal _distributionService;
     IProductService internal _productService;
     IPoolService internal _poolService;
 
     constructor(
         address registry,
-        NftId registryNftId
+        NftId registryNftId,
+        address initialOwner
     )
-        Registerable(registry, registryNftId)
         Versionable()
     {
+        bytes memory data = "";
+        _initializeRegisterable(registry, registryNftId, INSTANCE(), true, initialOwner, data);
         _keyValueStore = new KeyValueStore();
 
         _registerInterface(type(IInstance).interfaceId);
@@ -46,6 +50,14 @@ abstract contract InstanceBase is
 
     function getKeyValueStore() public view virtual override returns (IKeyValueStore keyValueStore) { return _keyValueStore; }
 
+    function updateState(Key32 key, StateId state) external override {
+        _keyValueStore.updateState(key, state);
+    }
+
+    function getState(Key32 key) external view override returns (StateId state) {
+        return _keyValueStore.getState(key);
+    }
+
     // from versionable
     function getVersion()
         public 
@@ -57,21 +69,18 @@ abstract contract InstanceBase is
     }
 
     // from registerable
-    function getType() external pure override returns (ObjectType objectType) {
-        return INSTANCE();
-    }
-
 
     // internal / private functions
     function _linkToServicesInRegistry() internal {
         VersionPart majorVersion = getVersion().toMajorPart();
         _componentOwnerService = IComponentOwnerService(_getAndCheck("ComponentOwnerService", majorVersion));
+        _distributionService = IDistributionService(_getAndCheck("DistributionService", majorVersion));
         _productService = IProductService(_getAndCheck("ProductService", majorVersion));
         _poolService = IPoolService(_getAndCheck("PoolService", majorVersion));
     }
 
     function _getAndCheck(string memory serviceName, VersionPart majorVersion) internal view returns (address serviceAddress) {
-        serviceAddress = _registry.getServiceAddress(serviceName, majorVersion);
+        serviceAddress = getRegistry().getServiceAddress(serviceName, majorVersion);
         require(
             serviceAddress != address(0),
             "ERROR:INS-001:NOT_REGISTERED"

package/contracts/instance/base/KeyValueStore.sol

@@ -54,7 +54,8 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         // set data
         _value[key32].data = data;
 
-        emit LogInfoCreated(toKey(key32), initialState, createdBy);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoCreated(toKey(key32), initialState, createdBy, tx.origin);
     }
 
     function update(Key32 key32, StateId state, bytes memory data) 
@@ -78,8 +79,10 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
 
         // create log entries
         Key memory key = toKey(key32);
-        emit LogStateUpdated(key, state, stateOld, updatedBy, lastUpdatedIn);
-        emit LogInfoUpdated(key, state, updatedBy, lastUpdatedIn);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogStateUpdated(key, state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoUpdated(key, state, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function updateData(Key32 key32, bytes memory data) 
@@ -101,7 +104,8 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
 
         // create log entry
         Key memory key = toKey(key32);
-        emit LogInfoUpdated(key, state, updatedBy, lastUpdatedIn);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoUpdated(key, state, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function updateState(Key32 key32, StateId state)
@@ -122,7 +126,8 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
 
         // create log entry
         Key memory key = toKey(key32);
-        emit LogStateUpdated(key, state, stateOld, updatedBy, lastUpdatedIn);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogStateUpdated(key, state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function exists(Key32 key32) public view returns (bool) {
@@ -145,11 +150,11 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         return _value[key32].metadata.state;
     }
 
-    function toKey32(ObjectType objectType, KeyId id) external pure returns(Key32) {
+    function toKey32(ObjectType objectType, KeyId id) external pure override returns(Key32) {
         return Key32Lib.toKey32(objectType, id);
     }
 
-    function toKey(Key32 key32) public pure returns (Key memory key) {
+    function toKey(Key32 key32) public pure override returns (Key memory key) {
         (ObjectType objectType, KeyId id) = key32.toKey();
         return Key(objectType, id);
     }

package/contracts/instance/base/Lifecycle.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.19;
 
 import {NftId} from "../../types/NftId.sol";
-import {ObjectType, PRODUCT, ORACLE, POOL, BUNDLE, POLICY} from "../../types/ObjectType.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK} from "../../types/ObjectType.sol";
 import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, UNDERWRITTEN, REVOKED, DECLINED} from "../../types/StateId.sol";
 import {ILifecycle} from "./ILifecycle.sol";
 
@@ -14,12 +14,10 @@ contract Lifecycle is ILifecycle {
         private _isValidTransition;
 
     constructor() {
-        _setupComponentLifecycle(PRODUCT());
-        _setupComponentLifecycle(ORACLE());
-        _setupComponentLifecycle(POOL());
-
         _setupBundleLifecycle();
+        _setupComponentLifecycle();
         _setupPolicyLifecycle();
+        _setupRiskLifecycle();
     }
 
     function hasLifecycle(
@@ -70,11 +68,11 @@ contract Lifecycle is ILifecycle {
         return _isValidTransition[objectType][fromId][toId];
     }
 
-    function _setupComponentLifecycle(ObjectType objectType) internal {
-        _initialState[objectType] = ACTIVE();
-        _isValidTransition[objectType][ACTIVE()][PAUSED()] = true;
-        _isValidTransition[objectType][PAUSED()][ACTIVE()] = true;
-        _isValidTransition[objectType][PAUSED()][ARCHIVED()] = true;
+    function _setupComponentLifecycle() internal {
+        _initialState[COMPONENT()] = ACTIVE();
+        _isValidTransition[COMPONENT()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[COMPONENT()][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[COMPONENT()][PAUSED()][ARCHIVED()] = true;
     }
 
     function _setupBundleLifecycle() internal {
@@ -92,4 +90,11 @@ contract Lifecycle is ILifecycle {
         _isValidTransition[POLICY()][UNDERWRITTEN()][ACTIVE()] = true;
         _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
     }
+
+    function _setupRiskLifecycle() internal {
+        _initialState[RISK()] = ACTIVE();
+        _isValidTransition[RISK()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[RISK()][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[RISK()][PAUSED()][ARCHIVED()] = true;
+    }
 }

package/contracts/instance/base/ModuleBase.sol

@@ -16,37 +16,42 @@ import {IKeyValueStore} from "./IKeyValueStore.sol";
 abstract contract ModuleBase {
 
     IKeyValueStore private _store;
-    ObjectType private _type;
 
-    function _initialize(IKeyValueStore keyValueStore, ObjectType objectType) internal {
+    function _initialize(IKeyValueStore keyValueStore) internal {
         _store = keyValueStore;
-        _type = objectType;
     }
 
-    function _create(NftId nftId, bytes memory data) internal {
+    function _create(ObjectType objectType, Key32 key, bytes memory data) internal {
         _store.create(
-            _toKey32(nftId), 
-            _type,
+            key, 
+            objectType,
             data);
     }
 
-    function _updateData(NftId nftId, bytes memory data) internal {
-        _store.updateData(_toKey32(nftId), data);
+    function _create(ObjectType objectType, NftId nftId, bytes memory data) internal {
+        _store.create(
+            nftId.toKey32(objectType), 
+            objectType,
+            data);
     }
 
-    function _updateState(NftId nftId, StateId state) internal {
-        _store.updateState(_toKey32(nftId), state);
+    function _updateData(ObjectType objectType, NftId nftId, bytes memory data) internal {
+        _store.updateData(nftId.toKey32(objectType), data);
     }
 
-    function _getData(NftId nftId) internal view returns(bytes memory data) {
-        return _store.getData(_toKey32(nftId));
+    function _updateState(ObjectType objectType, NftId nftId, StateId state) internal {
+        _store.updateState(nftId.toKey32(objectType), state);
     }
 
-    function _getState(NftId nftId) internal view returns(StateId) {
-        return _store.getState(_toKey32(nftId));
+    function _exists(ObjectType objectType, NftId nftId) internal view returns (bool hasData) {
+        return _store.exists(nftId.toKey32(objectType));
     }
 
-    function _toKey32(NftId nftId) internal view returns (Key32 key32) {
-        return nftId.toKey32(_type);
-    } 
+    function _getData(ObjectType objectType, NftId nftId) internal view returns(bytes memory data) {
+        return _store.getData(nftId.toKey32(objectType));
+    }
+
+    function _getState(ObjectType objectType, NftId nftId) internal view returns(StateId) {
+        return _store.getState(nftId.toKey32(objectType));
+    }
 }

package/contracts/instance/base/ServiceBase.sol

@@ -3,9 +3,10 @@ pragma solidity ^0.8.19;
 
 import {NftId, zeroNftId} from "../../types/NftId.sol";
 import {ObjectType, SERVICE} from "../../types/ObjectType.sol";
-import {Version, VersionPart} from "../../types/Version.sol";
+import {Version, VersionPart, VersionLib} from "../../types/Version.sol";
 
 import {Registerable} from "../../shared/Registerable.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
 
@@ -16,22 +17,28 @@ abstract contract ServiceBase is
     Versionable,
     IService
 {
+    function getName() public pure virtual override returns(string memory name);
 
-    constructor(
-        address registry,
-        NftId registryNftId
-    )
-        Registerable(registry, registryNftId)
-        Versionable()
-    {
-        _registerInterface(type(IService).interfaceId);
+    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
+        return getVersion().toMajorPart(); 
     }
 
-    function getMajorVersion() external view override returns(VersionPart majorVersion) {
-        return this.getVersion().toMajorPart();
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(3,0,0);
     }
 
-    function getType() external pure override returns (ObjectType) {
-        return SERVICE();
+    function _initializeServiceBase(address registry, NftId registryNftId, address initialOwner)
+        internal 
+        //onlyInitializing //TODO uncomment when "fully" upgradeable
+    {// service must provide its name and version upon registration
+        bytes memory data = abi.encode(getName(), getMajorVersion());
+        _initializeRegisterable(registry, registryNftId, SERVICE(), false, initialOwner, data);
+        _registerInterface(type(IService).interfaceId);
     }
 }

package/contracts/instance/module/bundle/BundleModule.sol

@@ -6,6 +6,7 @@ import {IRegistry} from "../../../registry/IRegistry.sol";
 import {IProductService} from "../../service/IProductService.sol";
 import {IPoolService} from "../../service/IPoolService.sol";
 
+import {Fee} from "../../../types/Fee.sol";
 import {NftId} from "../../../types/NftId.sol";
 import {Key32, KeyId} from "../../../types/Key32.sol";
 import {LibNftIdSet} from "../../../types/NftIdSet.sol";
@@ -55,12 +56,13 @@ abstract contract BundleModule is
     }
 
     function initializeBundleModule(IKeyValueStore keyValueStore) internal {
-        _initialize(keyValueStore, BUNDLE());
+        _initialize(keyValueStore);
     }
 
     function createBundleInfo(
         NftId bundleNftId,
         NftId poolNftId,
+        Fee memory fee,
         uint256 amount, 
         uint256 lifetime, 
         bytes calldata filter
@@ -69,9 +71,9 @@ abstract contract BundleModule is
         onlyBundlePoolService
         override
     {
-        BundleInfo memory bundleInfo = BundleInfo(
-            bundleNftId,
+        BundleInfo memory info = BundleInfo(
             poolNftId,
+            fee,
             filter,
             amount, // capital
             0, // locked capital
@@ -80,15 +82,15 @@ abstract contract BundleModule is
             zeroTimestamp() // closedAt
         );
 
-        _create(bundleNftId, abi.encode(bundleInfo));
+        _create(BUNDLE(), bundleNftId, abi.encode(info));
     }
 
-    function setBundleInfo(BundleInfo memory bundleInfo)
+    function setBundleInfo(NftId bundleNftId, BundleInfo memory info)
         external
         override
         onlyPoolOrProductService
     {
-        _updateData(bundleInfo.nftId, abi.encode(bundleInfo));
+        _updateData(BUNDLE(), bundleNftId, abi.encode(info));
     }
 
     function updateBundleState(NftId bundleNftId, StateId state)
@@ -96,7 +98,7 @@ abstract contract BundleModule is
         override
         onlyBundlePoolService
     {
-        _updateState(bundleNftId, state);
+        _updateState(BUNDLE(), bundleNftId, state);
     }
 
     function collateralizePolicy(
@@ -127,10 +129,6 @@ abstract contract BundleModule is
     }
 
     function getBundleInfo(NftId bundleNftId) external view override returns(BundleInfo memory bundleInfo) {
-        return abi.decode(_getData(bundleNftId), (BundleInfo));
+        return abi.decode(_getData(BUNDLE(), bundleNftId), (BundleInfo));
     }
-
-    function toBundleKey32(NftId bundleNftId) external view override returns (Key32 key32) {
-        return _toKey32(bundleNftId);
-    } 
 }

package/contracts/instance/module/bundle/IBundle.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.19;
 
 import {IRegistry} from "../../../registry/IRegistry.sol";
 import {IInstance} from "../../IInstance.sol";
+import {Fee} from "../../../types/Fee.sol";
 import {Key32} from "../../../types/Key32.sol";
 import {NftId} from "../../../types/NftId.sol";
 import {StateId} from "../../../types/StateId.sol";
@@ -16,8 +17,8 @@ import {IPoolService} from "../../service/IPoolService.sol";
 interface IBundle {
 
     struct BundleInfo {
-        NftId nftId;
         NftId poolNftId;
+        Fee fee; // bundle fee on net premium amounts
         bytes filter; // required conditions for applications to be considered for collateralization by this bundle
         uint256 capitalAmount; // net investment capital amount (<= balance)
         uint256 lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= balance)
@@ -32,25 +33,19 @@ interface IBundleModule is IBundle {
     function createBundleInfo(
         NftId bundleNftId,
         NftId poolNftId,
+        Fee memory fee,
         uint256 amount, 
         uint256 lifetime, 
         bytes calldata filter
     ) external;
 
-    function setBundleInfo(BundleInfo memory bundleInfo) external;
-    function updateBundleState(NftId bundleNftId, StateId state) external;
+    function setBundleInfo(NftId nftId, BundleInfo memory bundleInfo) external;
+    function updateBundleState(NftId nftId, StateId state) external;
 
     function collateralizePolicy(NftId bundleNftId, NftId policyNftId, uint256 amount) external;
     function releasePolicy(NftId bundleNftId, NftId policyNftId) external returns(uint256 collateralAmount);
 
-    function getBundleInfo(NftId bundleNftId) external view returns(BundleInfo memory bundleInfo);
-    function toBundleKey32(NftId bundleNftId) external view returns (Key32 key32);
-
-    // repeat registry linked signature
-    function getRegistry() external view returns (IRegistry registry);
-
-    // repeat instance base signature
-    function getKeyValueStore() external view returns (IKeyValueStore keyValueStore);
+    function getBundleInfo(NftId nftId) external view returns(BundleInfo memory bundleInfo);
 
     // repeat service linked signatures to avoid linearization issues
     function getProductService() external returns(IProductService);