@etherisc/gif-next 0.0.2-b75de7e-093 → 0.0.2-b7d6ed2-016

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -7,10 +7,14 @@ import {
 
 import {IAccess} from "../authorization/IAccess.sol";
 import {IAccountingService} from "../accounting/IAccountingService.sol";
+import {IApplicationService} from "../product/IApplicationService.sol";
 import {IBundleService} from "../pool/IBundleService.sol";
 import {IClaimService} from "../product/IClaimService.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
 import {IDistributionService} from "../distribution/IDistributionService.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IOracleService} from "../oracle/IOracleService.sol";
+import {IPolicyService} from "../product/IPolicyService.sol";
 import {IPoolService} from "../pool/IPoolService.sol";
 import {IStakingService} from "../staking/IStakingService.sol";
 import {IRegistryService} from "./IRegistryService.sol";
@@ -62,6 +66,9 @@ contract ServiceAuthorizationV3
           _setupDistributionServiceAuthorization();
           _setupPoolServiceAuthorization();
           _setupBundleServiceAuthorization();
+          _setupOracleServiceAuthorization();
+          _setupApplicationServiceAuthorization();
+          _setupPolicyServiceAuthorization();
      }
 
 
@@ -104,6 +111,7 @@ contract ServiceAuthorizationV3
           _authorize(functions, IStakingService.createInstanceTarget.selector, "createInstanceTarget");
           _authorize(functions, IStakingService.setInstanceLockingPeriod.selector, "setInstanceLockingPeriod");
           _authorize(functions, IStakingService.setInstanceRewardRate.selector, "setInstanceRewardRate");
+          _authorize(functions, IStakingService.setInstanceMaxStakedAmount.selector, "setInstanceMaxStakedAmount");
           _authorize(functions, IStakingService.refillInstanceRewardReserves.selector, "refillInstanceRewardReserves");
           _authorize(functions, IStakingService.withdrawInstanceRewardReserves.selector, "withdrawInstanceRewardReserves");
 
@@ -123,12 +131,16 @@ contract ServiceAuthorizationV3
      {
           IAccess.FunctionInfo[] storage functions;
           functions = _authorizeForService(INSTANCE(), ALL());
+          _authorize(functions, IInstanceService.setInstanceLocked.selector, "setInstanceLocked");
+          _authorize(functions, IInstanceService.setTargetLocked.selector, "setTargetLocked");
+
           _authorize(functions, IInstanceService.createInstance.selector, "createInstance");
           _authorize(functions, IInstanceService.upgradeInstanceReader.selector, "upgradeInstanceReader");
           _authorize(functions, IInstanceService.upgradeMasterInstanceReader.selector, "upgradeMasterInstanceReader");
 
           _authorize(functions, IInstanceService.setStakingLockingPeriod.selector, "setStakingLockingPeriod");
           _authorize(functions, IInstanceService.setStakingRewardRate.selector, "setStakingRewardRate");
+          _authorize(functions, IInstanceService.setStakingMaxAmount.selector, "setStakingMaxAmount");
           _authorize(functions, IInstanceService.refillStakingRewardReserves.selector, "refillStakingRewardReserves");
           _authorize(functions, IInstanceService.withdrawStakingRewardReserves.selector, "withdrawStakingRewardReserves");
      }
@@ -143,9 +155,6 @@ contract ServiceAuthorizationV3
           _authorize(functions, IAccountingService.increaseBundleBalance.selector, "increaseBundleBalance");
           _authorize(functions, IAccountingService.decreaseBundleBalance.selector, "decreaseBundleBalance");
 
-          functions = _authorizeForService(ACCOUNTING(), POOL());
-          _authorize(functions, IAccountingService.decreaseBundleBalanceForPool.selector, "decreaseBundleBalanceForPool");
-
           functions = _authorizeForService(ACCOUNTING(), COMPONENT());
           _authorize(functions, IAccountingService.decreaseComponentFees.selector, "decreaseComponentFees");
 
@@ -171,6 +180,19 @@ contract ServiceAuthorizationV3
      function _setupComponentServiceAuthorization()
           internal
      {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(COMPONENT(), ALL());
+          _authorize(functions, IComponentService.registerComponent.selector, "registerComponent");
+          _authorize(functions, IComponentService.approveTokenHandler.selector, "approveTokenHandler");
+          _authorize(functions, IComponentService.setWallet.selector, "setWallet");
+          _authorize(functions, IComponentService.setLocked.selector, "setLocked");
+          _authorize(functions, IComponentService.withdrawFees.selector, "withdrawFees");
+          _authorize(functions, IComponentService.registerProduct.selector, "registerProduct");
+          _authorize(functions, IComponentService.setProductFees.selector, "setProductFees");
+          _authorize(functions, IComponentService.setDistributionFees.selector, "setDistributionFees");
+          _authorize(functions, IComponentService.setPoolFees.selector, "setPoolFees");
+
      }
 
      /// @dev Distribution service function authorization.
@@ -191,6 +213,14 @@ contract ServiceAuthorizationV3
           IAccess.FunctionInfo[] storage functions;
           functions = _authorizeForService(CLAIM(), ALL());
           _authorize(functions, IClaimService.submit.selector, "submit");
+          _authorize(functions, IClaimService.confirm.selector, "confirm");
+          _authorize(functions, IClaimService.decline.selector, "decline");
+          _authorize(functions, IClaimService.revoke.selector, "revoke");
+          _authorize(functions, IClaimService.close.selector, "close");
+          _authorize(functions, IClaimService.createPayoutForBeneficiary.selector, "createPayoutForBeneficiary");
+          _authorize(functions, IClaimService.createPayout.selector, "createPayout");
+          _authorize(functions, IClaimService.processPayout.selector, "processPayout");
+          _authorize(functions, IClaimService.cancelPayout.selector, "cancelPayout");
      }
 
      /// @dev Distribution service function authorization.
@@ -201,6 +231,13 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(DISTRIBUTION(), POLICY());
           _authorize(functions, IDistributionService.processSale.selector, "processSale");
           _authorize(functions, IDistributionService.processReferral.selector, "processReferral");
+
+          functions = _authorizeForService(DISTRIBUTION(), ALL());
+          _authorize(functions, IDistributionService.createDistributorType.selector, "createDistributorType");
+          _authorize(functions, IDistributionService.createDistributor.selector, "createDistributor");
+          _authorize(functions, IDistributionService.changeDistributorType.selector, "changeDistributorType");
+          _authorize(functions, IDistributionService.createReferral.selector, "createReferral");
+          _authorize(functions, IDistributionService.withdrawCommission.selector, "withdrawCommission");
      }
 
 
@@ -219,6 +256,13 @@ contract ServiceAuthorizationV3
           _authorize(functions, IPoolService.processPayout.selector, "processPayout");
 
           functions = _authorizeForService(POOL(), ALL());
+          _authorize(functions, IPoolService.setMaxBalanceAmount.selector, "setMaxBalanceAmount");
+          _authorize(functions, IPoolService.closeBundle.selector, "closeBundle");
+          _authorize(functions, IPoolService.processFundedClaim.selector, "processFundedClaim");
+          _authorize(functions, IPoolService.stake.selector, "stake");
+          _authorize(functions, IPoolService.unstake.selector, "unstake");
+          _authorize(functions, IPoolService.fundPoolWallet.selector, "fundPoolWallet");
+          _authorize(functions, IPoolService.defundPoolWallet.selector, "defundPoolWallet");
           _authorize(functions, IPoolService.withdrawBundleFees.selector, "withdrawBundleFees");
      }
 
@@ -243,5 +287,45 @@ contract ServiceAuthorizationV3
           _authorize(functions, IBundleService.unlock.selector, "unlock");
           _authorize(functions, IBundleService.setFee.selector, "setFee");
      }
+
+     function _setupOracleServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(ORACLE(), ALL());
+          _authorize(functions, IOracleService.request.selector, "request");
+          _authorize(functions, IOracleService.respond.selector, "respond");
+          _authorize(functions, IOracleService.resend.selector, "resend");
+          _authorize(functions, IOracleService.cancel.selector, "cancel");
+     }
+
+     function _setupApplicationServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(APPLICATION(), ALL());
+          _authorize(functions, IApplicationService.create.selector, "create");
+          _authorize(functions, IApplicationService.renew.selector, "renew");
+          _authorize(functions, IApplicationService.adjust.selector, "adjust");
+          _authorize(functions, IApplicationService.revoke.selector, "revoke");
+     }
+
+     function _setupPolicyServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(POLICY(), ALL());
+          _authorize(functions, IPolicyService.decline.selector, "decline");
+          _authorize(functions, IPolicyService.createPolicy.selector, "createPolicy");
+          _authorize(functions, IPolicyService.collectPremium.selector, "collectPremium");
+          _authorize(functions, IPolicyService.activate.selector, "activate");
+          _authorize(functions, IPolicyService.expire.selector, "expire");
+          _authorize(functions, IPolicyService.expirePolicy.selector, "expirePolicy");
+          _authorize(functions, IPolicyService.close.selector, "close");
+
+     }
 }
 

package/contracts/registry/TokenRegistry.sol

@@ -35,10 +35,13 @@ contract TokenRegistry is
     error ErrorTokenRegistryMajorVersionInvalid(VersionPart majorVersion);
 
     struct TokenInfo {
+        // slot 0
         uint256 chainId;
+        // slot 1
+        string symbol;
+        // slot 2
         address token;
         uint8 decimals;
-        string symbol;
         bool active;
     }
 

package/contracts/shared/Component.sol

@@ -4,19 +4,15 @@ pragma solidity ^0.8.20;
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
+import {Amount} from "../type/Amount.sol";
 import {IComponent} from "./IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "./IComponentService.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {IRelease} from "../registry/IRelease.sol";
-
-import {Amount, AmountLib} from "../type/Amount.sol";
-import {ContractLib} from "./ContractLib.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, STAKING} from "../type/ObjectType.sol";
+import {ObjectType, COMPONENT} from "../type/ObjectType.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {Version, VersionLib, VersionPart} from "../type/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
 
 
 abstract contract Component is
@@ -28,7 +24,6 @@ abstract contract Component is
 
     struct ComponentStorage {
         string _name; // unique (per instance) component name
-        IERC20Metadata _token; // token for this component
         bool _isInterceptor;
         bytes _data;
         IComponentService _componentService;
@@ -44,6 +39,7 @@ abstract contract Component is
 
 
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
         assembly {
             $.slot := COMPONENT_LOCATION_V1
         }
@@ -55,7 +51,6 @@ abstract contract Component is
         address registry,
         NftId parentNftId,
         string memory name,
-        address token,
         ObjectType componentType,
         bool isInterceptor,
         address initialOwner,
@@ -66,20 +61,6 @@ abstract contract Component is
         virtual
         onlyInitializing()
     {
-        address tokenRegistry = IRegistry(registry).getTokenRegistryAddress();
-        VersionPart release = IRelease(authority).getRelease();
-
-        // special case for staking: component intitialization happens before
-        // GIF core contract setup is complete. at that time token registry 
-        // is not yet available. therefore we skip the check for staking.
-        if (componentType != STAKING()) {
-
-            // check if provided token is whitelisted and active
-            if (!ContractLib.isActiveToken(tokenRegistry, token, block.chainid, release)) {
-                revert ErrorComponentTokenInvalid(token);
-            }
-        }
-
         if (bytes(name).length == 0) {
             revert ErrorComponentNameLengthZero();
         }
@@ -96,7 +77,6 @@ abstract contract Component is
         // set component state
         ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
-        $._token = IERC20Metadata(token);
         $._isInterceptor = isInterceptor;
         $._data = componentData;
         $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
@@ -111,7 +91,7 @@ abstract contract Component is
     /// override internal function _nftTransferFrom to implement custom behaviour
     function nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         external
-        onlyChainNft()
+        onlyChainNft
     {
         _nftTransferFrom(from, to, tokenId, operator);
     }
@@ -126,7 +106,7 @@ abstract contract Component is
     }
 
     function getToken() public view virtual returns (IERC20Metadata token) {
-        return getComponentInfo().token;
+        return getTokenHandler().TOKEN();
     }
 
     function getName() public view override returns(string memory name) {
@@ -184,10 +164,14 @@ abstract contract Component is
     function _nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         internal
         virtual
-    { }
+    // solhint-disable-next-line no-empty-blocks
+    { 
+        // empty default implementation
+    }
 
 
-    /// @dev depending on the source of the component information this function needs to be overwritten. 
+    /// @dev Sets the components wallet to the specified address.
+    /// Depending on the source of the component information this function needs to be overwritten. 
     /// eg for instance linked components that externally store this information with the instance store contract
     function _setWallet(
         address newWallet
@@ -202,7 +186,7 @@ abstract contract Component is
         internal
         virtual
     {
-        _getComponentStorage()._componentService.setLockedFromComponent(address(this), locked);
+        _getComponentStorage()._componentService.setLocked(locked);
     }
 
 
@@ -213,7 +197,6 @@ abstract contract Component is
         
         return IComponents.ComponentInfo({
             name: $._name,
-            token: $._token,
             tokenHandler: TokenHandler(address(0)),
             data: $._data // user specific component data
         });

package/contracts/shared/ComponentService.sol

@@ -19,6 +19,7 @@ import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
 
+import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {ContractLib} from "../shared/ContractLib.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
@@ -98,15 +99,18 @@ contract ComponentService is
         returns (NftId componentNftId)
     {
         // type specific registration
-        ObjectType componentType = IInstanceLinkedComponent(component).getInitialInfo().objectType;
+        IRegistry.ObjectInfo memory componentObjectInfo = IInstanceLinkedComponent(component).getInitialInfo();
+        ObjectType componentType = componentObjectInfo.objectType;        
+        IComponent productComponent = IComponent(getRegistry().getObjectAddress(componentObjectInfo.parentNftId));
+
         if (componentType == POOL()) {
-            return _registerPool(component);
+            return _registerPool(component, address(productComponent.getToken()));
         }
         if (componentType == DISTRIBUTION()) {
-            return _registerDistribution(component);
+            return _registerDistribution(component, address(productComponent.getToken()));
         }
         if (componentType == ORACLE()) {
-            return _registerOracle(component);
+            return _registerOracle(component, address(productComponent.getToken()));
         }
 
         // fail
@@ -144,31 +148,24 @@ contract ComponentService is
     }
 
     /// @inheritdoc IComponentService
-    function setLockedFromInstance(address componentAddress, bool locked) 
+    function setLocked(bool locked) 
         external 
         virtual
-        onlyInstance()
-    {
-        address instanceAddress = msg.sender;
-        // NftId instanceNftId = getRegistry().getNftIdForAddress(msg.sender);
-        IInstance instance = IInstance(instanceAddress);
-        _setLocked(instance.getInstanceAdmin(), componentAddress, locked);
-    }
-
-    /// @inheritdoc IComponentService
-    function setLockedFromComponent(address componentAddress, bool locked) 
-        external
-        virtual
-        onlyComponent(msg.sender)
+        restricted()
     {
         (, IInstance instance) = _getAndVerifyComponent(COMPONENT(), false);
-        _setLocked(instance.getInstanceAdmin(), componentAddress, locked);
+
+        address component = msg.sender;
+        instance.getInstanceAdmin().setComponentLocked(
+            component, 
+            locked);
     }
 
     /// @inheritdoc IComponentService
     function withdrawFees(Amount amount)
         external
         virtual
+        restricted()
         returns (Amount withdrawnAmount)
     {
         // checks
@@ -198,6 +195,7 @@ contract ComponentService is
             componentNftId, 
             withdrawnAmount);
         
+        // transfer amount to component owner
         address componentOwner = getRegistry().ownerOf(componentNftId);
         TokenHandler tokenHandler = instanceReader.getTokenHandler(componentNftId);
         emit LogComponentServiceComponentFeesWithdrawn(
@@ -216,7 +214,7 @@ contract ComponentService is
 
     //-------- product ------------------------------------------------------//
 
-    function registerProduct(address productAddress)
+    function registerProduct(address productAddress, address token)
         external
         virtual
         nonReentrant()
@@ -228,7 +226,8 @@ contract ComponentService is
         InstanceStore instanceStore;
         (, instanceAdmin, instanceStore,, productNftId) = _register(
             productAddress,
-            PRODUCT());
+            PRODUCT(),
+            token);
 
         // get product
         IProductComponent product = IProductComponent(productAddress);
@@ -286,7 +285,7 @@ contract ComponentService is
     //-------- distribution -------------------------------------------------//
 
     /// @dev registers the sending component as a distribution component
-    function _registerDistribution(address distributioAddress)
+    function _registerDistribution(address distributioAddress, address token)
         internal
         virtual
         nonReentrant()
@@ -299,7 +298,8 @@ contract ComponentService is
         NftId productNftId;
         (instanceReader, instanceAdmin, instanceStore, productNftId, distributionNftId) = _register(
             distributioAddress,
-            DISTRIBUTION());
+            DISTRIBUTION(),
+            token);
 
         // check product is still expecting a distribution registration
         IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
@@ -350,7 +350,7 @@ contract ComponentService is
 
     //-------- oracle -------------------------------------------------------//
 
-    function _registerOracle(address oracleAddress)
+    function _registerOracle(address oracleAddress, address token)
         internal
         virtual
         returns (NftId oracleNftId)
@@ -363,7 +363,8 @@ contract ComponentService is
 
         (instanceReader, instanceAdmin, instanceStore, productNftId, oracleNftId) = _register(
             oracleAddress,
-            ORACLE());
+            ORACLE(),
+            token);
 
         // check product is still expecting an oracle registration
         IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
@@ -382,7 +383,7 @@ contract ComponentService is
 
     //-------- pool ---------------------------------------------------------//
 
-    function _registerPool(address poolAddress)
+    function _registerPool(address poolAddress, address token)
         internal
         virtual
         returns (NftId poolNftId)
@@ -395,7 +396,8 @@ contract ComponentService is
 
         (instanceReader, instanceAdmin, instanceStore, productNftId, poolNftId) = _register(
             poolAddress,
-            POOL());
+            POOL(),
+            token);
 
         // check product is still expecting a pool registration
         IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
@@ -459,7 +461,8 @@ contract ComponentService is
     /// @dev Registers the component represented by the provided address.
     function _register(
         address componentAddress, // address of component to register
-        ObjectType requiredType // required type for component for registration
+        ObjectType requiredType, // required type for component for registration
+        address token
     )
         internal
         virtual
@@ -487,6 +490,18 @@ contract ComponentService is
             componentAddress,
             requiredType);
 
+        if (! instance.isTokenRegistryDisabled()) {
+            // check if provided token is whitelisted and active
+            if (!ContractLib.isActiveToken(
+                getRegistry().getTokenRegistryAddress(), 
+                token, 
+                block.chainid, 
+                AccessManagerCloneable(authority()).getRelease())
+            ) {
+                revert ErrorComponentServiceTokenInvalid(token);
+            }
+        }
+
         // get instance supporting contracts (as function return values)
         instanceReader = instance.getInstanceReader();
         instanceAdmin = instance.getInstanceAdmin();
@@ -502,26 +517,27 @@ contract ComponentService is
         }
 
         // deploy and wire token handler
-        IComponents.ComponentInfo memory componentInfo = component.getInitialComponentInfo();
-        IERC20Metadata token = componentInfo.token;
-        componentInfo.tokenHandler = TokenHandlerDeployerLib.deployTokenHandler(
-            address(getRegistry()),
-            address(component), // initially, component is its own wallet
-            address(token), 
-            address(instanceAdmin.authority()));
-        
-        // register component with instance
-        instanceStore.createComponent(
-            componentNftId, 
-            componentInfo);
+        {
+            IComponents.ComponentInfo memory componentInfo = component.getInitialComponentInfo();
+            componentInfo.tokenHandler = TokenHandlerDeployerLib.deployTokenHandler(
+                address(getRegistry()),
+                componentAddress, // initially, component is its own wallet
+                token, 
+                address(instanceAdmin.authority()));
+            
+            // register component with instance
+            instanceStore.createComponent(
+                componentNftId, 
+                componentInfo);
+        }
 
         // link component contract to nft id
         component.linkToRegisteredNftId();
 
         // authorize
-        instanceAdmin.initializeComponentAuthorization(component);
+        instanceAdmin.initializeComponentAuthorization(componentAddress, requiredType);
 
-        emit LogComponentServiceRegistered(instanceNftId, componentNftId, requiredType, address(component), address(token), initialOwner);
+        emit LogComponentServiceRegistered(instanceNftId, componentNftId, requiredType, componentAddress, token, initialOwner);
     }
 
 

package/contracts/shared/ContractLib.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.20;
 
 import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
 import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
 // import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
@@ -170,6 +171,33 @@ library ContractLib {
     }
 
 
+    function isAccessManaged(address target)
+        public
+        view
+        returns (bool)
+    {
+        if (!isContract(target)) {
+            return false;
+        }
+
+        (bool success, ) = target.staticcall(
+            abi.encodeWithSelector(
+                IAccessManaged.authority.selector));
+
+        return success;
+    }
+
+
+    function isRegistered(address registry, address caller, ObjectType expectedType) public view returns (bool) {
+        NftId nftId = IRegistry(registry).getNftIdForAddress(caller);
+        if (nftId.eqz()) {
+            return false;
+        }
+
+        return IRegistry(registry).getObjectInfo(nftId).objectType == expectedType;
+    }
+
+
     function isRegistry(address registry) public view returns (bool) {
         if (!isContract(registry)) {
             return false;

package/contracts/shared/IComponent.sol

@@ -15,9 +15,6 @@ interface IComponent is
     IRegisterable,
     ITransferInterceptor
 {
-
-    error ErrorComponentTokenInvalid(address token);
-
     error ErrorComponentProductNftIdZero();
     error ErrorComponentProductNftIdNonzero();
     error ErrorComponentNameLengthZero();

package/contracts/shared/IComponentService.sol

@@ -16,6 +16,8 @@ import {VersionPart} from "../type/Version.sol";
 interface IComponentService is 
     IService
 {
+    error ErrorComponentServiceTokenInvalid(address token);
+
     error ErrorComponentServiceNotInstanceLinkedComponent(address component);
     error ErrorComponentServiceSenderNotRegistered(address sender);
     error ErrorComponentServiceNotComponent(address component);
@@ -56,9 +58,9 @@ interface IComponentService is
         NftId nftId, 
         string feeName, 
         UFixed previousFractionalFee, 
-        uint256 previousFixedFee,
+        Amount previousFixedFee,
         UFixed newFractionalFee, 
-        uint256 newFixedFee
+        Amount newFixedFee
     );
     
     //-------- component ----------------------------------------------------//
@@ -67,14 +69,12 @@ interface IComponentService is
     /// Reverts if the component's token handler wallet is not the token handler itself.
     function approveTokenHandler(IERC20Metadata token, Amount amount) external;
 
-    /// @dev Sets the components associated wallet address
+    /// @dev Sets the components associated wallet address.
+    /// To set the wallet to the token handler contract, use address(0) as the new wallet adress.
     function setWallet(address newWallet) external;
 
-    /// @dev Locks/Unlocks the given component - call from instanceService
-    function setLockedFromInstance(address componentAddress, bool locked) external;
-
-    /// @dev Locks/Unlocks the given component - call from component
-    function setLockedFromComponent(address componentAddress, bool locked) external;
+    /// @dev Locks/Unlocks the calling component.
+    function setLocked(bool locked) external;
 
     /// @dev Withdraw fees from the distribution component. Only component owner is allowed to withdraw fees.
     /// @param withdrawAmount the amount to withdraw
@@ -87,7 +87,7 @@ interface IComponentService is
     //-------- product ------------------------------------------------------//
 
     /// @dev Registers the specified product component for the instance (sender)
-    function registerProduct(address product) external returns (NftId productNftId);
+    function registerProduct(address product, address token) external returns (NftId productNftId);
 
     function setProductFees(
         Fee memory productFee, // product fee on net premium

package/contracts/shared/InitializableERC165.sol

@@ -11,13 +11,21 @@ contract InitializableERC165 is
     mapping(bytes4 => bool) private _isSupported;
 
     // @dev initializes with support for ERC165
-    function _initializeERC165() internal onlyInitializing() {
+    function __ERC165_init() internal onlyInitializing() {
+        _initializeERC165();
+    }
+
+    function _initializeERC165() internal {
         _isSupported[type(IERC165).interfaceId] = true;
     }
 
     // @dev register support for provided interfaceId
     // includes initialization for ERC165_ID if not yet done
     function _registerInterface(bytes4 interfaceId) internal onlyInitializing() {
+        _registerInterfaceNotInitializing(interfaceId);
+    }
+
+    function _registerInterfaceNotInitializing(bytes4 interfaceId) internal{
         _isSupported[interfaceId] = true;
     }
 

package/contracts/shared/InstanceLinkedComponent.sol

@@ -71,7 +71,6 @@ abstract contract InstanceLinkedComponent is
         address registry,
         NftId parentNftId,
         string memory name,
-        address token,
         ObjectType componentType,
         IAuthorization authorization,
         bool isInterceptor,
@@ -99,7 +98,6 @@ abstract contract InstanceLinkedComponent is
             registry, 
             parentNftId, 
             name, 
-            token,
             componentType, 
             isInterceptor, 
             initialOwner,