@etherisc/gif-next 0.0.2-de220d6-949 → 0.0.2-e37834a-021

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,7 +3,7 @@ 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 {IVersionable} from "../../shared/IVersionable.sol";
@@ -16,22 +16,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/access/Access.sol

@@ -6,8 +6,8 @@ pragma solidity ^0.8.19;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 import {RoleId, RoleIdLib} from "../../../types/RoleId.sol";
-import {DISTRIBUTOR_OWNER_ROLE, ORACLE_OWNER_ROLE, POOL_OWNER_ROLE, PRODUCT_OWNER_ROLE} from "../../../types/RoleId.sol";
-import {DISTRIBUTOR_OWNER_ROLE_NAME, ORACLE_OWNER_ROLE_NAME, POOL_OWNER_ROLE_NAME, PRODUCT_OWNER_ROLE_NAME} from "../../../types/RoleId.sol";
+import {DISTRIBUTION_OWNER_ROLE, ORACLE_OWNER_ROLE, POOL_OWNER_ROLE, PRODUCT_OWNER_ROLE} from "../../../types/RoleId.sol";
+import {DISTRIBUTION_OWNER_ROLE_NAME, ORACLE_OWNER_ROLE_NAME, POOL_OWNER_ROLE_NAME, PRODUCT_OWNER_ROLE_NAME} from "../../../types/RoleId.sol";
 import {IAccessModule} from "./IAccess.sol";
 
 abstract contract AccessModule is IAccessModule {
@@ -36,7 +36,7 @@ abstract contract AccessModule is IAccessModule {
     }
 
     constructor() {
-        _createRole(DISTRIBUTOR_OWNER_ROLE(), DISTRIBUTOR_OWNER_ROLE_NAME());
+        _createRole(DISTRIBUTION_OWNER_ROLE(), DISTRIBUTION_OWNER_ROLE_NAME());
         _createRole(ORACLE_OWNER_ROLE(), ORACLE_OWNER_ROLE_NAME());
         _createRole(POOL_OWNER_ROLE(), POOL_OWNER_ROLE_NAME());
         _createRole(PRODUCT_OWNER_ROLE(), PRODUCT_OWNER_ROLE_NAME());

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

package/contracts/instance/module/component/ComponentModule.sol

@@ -1,75 +1,57 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IERC20Metadata} from "@openzeppelin5/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IKeyValueStore} from "../../base/IKeyValueStore.sol";
+import {IComponentModule} from "./IComponent.sol";
 
-import {IRegistry} from "../../../registry/IRegistry.sol";
-import {IInstance} from "../../IInstance.sol";
+import {NftId} from "../../../types/NftId.sol";
+import {ObjectType, COMPONENT} from "../../../types/ObjectType.sol";
+import {StateId} from "../../../types/StateId.sol";
+import {ModuleBase} from "../../base/ModuleBase.sol";
 
-import {IComponent, IComponentModule} from "./IComponent.sol";
-import {IComponentOwnerService} from "../../service/IComponentOwnerService.sol";
-import {ObjectType, PRODUCT, ORACLE, POOL} from "../../../types/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED} from "../../../types/StateId.sol";
-import {NftId, NftIdLib, zeroNftId} from "../../../types/NftId.sol";
-import {Fee} from "../../../types/Fee.sol";
-
-abstract contract ComponentModule is
+abstract contract ComponentModule is 
+    ModuleBase,
     IComponentModule
 {
-    using NftIdLib for NftId;
 
-    mapping(NftId nftId => ComponentInfo info) private _componentInfo;
     NftId[] private _nftIds;
 
-    mapping(ObjectType cType => bytes32 role) private _componentOwnerRole;
-
-    modifier onlyComponentOwnerService() {
+    // TODO try to keep 1 modifier in 1 place...
+    modifier onlyComponentOwnerService() virtual {
         require(
             msg.sender == address(this.getComponentOwnerService()),
-            "ERROR:CMP-001:NOT_OWNER_SERVICE"
+            "ERROR:CMP-001:NOT_COMPONENT_OWNER_SERVICE"
         );
         _;
     }
 
+    function initializeComponentModule(IKeyValueStore keyValueStore) internal {
+        _initialize(keyValueStore);
+    }
+
     function registerComponent(
         NftId nftId,
-        ObjectType, // objectType,
-        IERC20Metadata token
-    ) external override onlyComponentOwnerService {
-
-        // create component info
-        _componentInfo[nftId] = ComponentInfo(
-            nftId,
-            // _lifecycleModule.getInitialState(objectType),
-            ACTIVE(),
-            token
-        );
-
+        IERC20Metadata token,
+        address wallet
+    )
+        external
+        onlyComponentOwnerService
+        override
+    {
+        ComponentInfo memory info = ComponentInfo(token, wallet);
         _nftIds.push(nftId);
-
-        // TODO add logging
+        _create(COMPONENT(), nftId, abi.encode(info));
     }
 
-    function setComponentInfo(
-        ComponentInfo memory info
-    ) external onlyComponentOwnerService returns (NftId nftId) {
-        nftId = info.nftId;
-        require(
-            nftId.gtz() && _componentInfo[nftId].nftId.eq(nftId),
-            "ERROR:CMP-006:COMPONENT_UNKNOWN"
-        );
+    function getComponentToken(NftId nftId) external view override returns(IERC20Metadata token) {
+        ComponentInfo memory info = abi.decode(_getData(COMPONENT(), nftId), (ComponentInfo));
+        return info.token;
+    }
 
-        // TODO decide if state changes should have explicit functions and not
-        // just a generic setXYZInfo and implicit state transitions
-        // when in doubt go for the explicit approach ...
-        // ObjectType objectType = this.getRegistry().getObjectInfo(nftId).objectType;
-        // _lifecycleModule.checkAndLogTransition(
-        //     nftId,
-        //     objectType,
-        //     _componentInfo[nftId].state,
-        //     info.state
-        // );
-        _componentInfo[nftId] = info;
+    function getComponentWallet(NftId nftId) external view override returns (address wallet) {
+        ComponentInfo memory info = abi.decode(_getData(COMPONENT(), nftId), (ComponentInfo));
+        return info.wallet;
     }
 
     function getComponentCount()
@@ -86,10 +68,4 @@ abstract contract ComponentModule is
     ) external view override returns (NftId componentNftId) {
         return _nftIds[idx];
     }
-
-    function getComponentInfo(
-        NftId nftId
-    ) external view override returns (ComponentInfo memory) {
-        return _componentInfo[nftId];
-    }
-}
+}