@etherisc/gif-next 0.0.2-9e03baf-990 → 0.0.2-9e6b423-414

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -2,16 +2,24 @@
 pragma solidity ^0.8.20;
 
 import {
-     ALL, REGISTRY, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKING, PRICE
+     ALL, RELEASE, ACCOUNTING, REGISTRY, RISK, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, APPLICATION, POLICY, CLAIM, BUNDLE, STAKING, PRICE
 } from "../../contracts/type/ObjectType.sol";
 
 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";
+import {IRiskService} from "../product/IRiskService.sol";
+
 import {ServiceAuthorization} from "../authorization/ServiceAuthorization.sol";
 
 
@@ -20,26 +28,31 @@ contract ServiceAuthorizationV3
 {
 
      constructor(string memory commitHash)
-          ServiceAuthorization(commitHash, 3)
+          ServiceAuthorization(
+               "ReleaseAdmin",
+               RELEASE(),
+               3,
+               commitHash)
      {}
 
      function _setupDomains()
           internal
           override
      {
-          _authorizeDomain(REGISTRY(), address(1));
-          _authorizeDomain(STAKING(), address(2));
-          _authorizeDomain(INSTANCE(), address(3));
-          _authorizeDomain(COMPONENT(), address(4));
-          _authorizeDomain(DISTRIBUTION(), address(5));
-          _authorizeDomain(PRICE(), address(6));
-          _authorizeDomain(BUNDLE(), address(7));
-          _authorizeDomain(POOL(), address(8));
-          _authorizeDomain(ORACLE(), address(9));
-          _authorizeDomain(PRODUCT(), address(10));
-          _authorizeDomain(POLICY(), address(11));
-          _authorizeDomain(CLAIM(), address(12));
-          _authorizeDomain(APPLICATION(), address(13));
+          _authorizeServiceDomain(REGISTRY(), address(1));
+          _authorizeServiceDomain(STAKING(), address(2));
+          _authorizeServiceDomain(INSTANCE(), address(3));
+          _authorizeServiceDomain(ACCOUNTING(), address(4));
+          _authorizeServiceDomain(COMPONENT(), address(5));
+          _authorizeServiceDomain(DISTRIBUTION(), address(6));
+          _authorizeServiceDomain(PRICE(), address(7));
+          _authorizeServiceDomain(BUNDLE(), address(8));
+          _authorizeServiceDomain(POOL(), address(9));
+          _authorizeServiceDomain(ORACLE(), address(10));
+          _authorizeServiceDomain(RISK(), address(11));
+          _authorizeServiceDomain(POLICY(), address(12));
+          _authorizeServiceDomain(CLAIM(), address(13));
+          _authorizeServiceDomain(APPLICATION(), address(14));
      }
 
 
@@ -47,19 +60,25 @@ contract ServiceAuthorizationV3
           internal
           override
      {
-          _setupIRegistryServiceAuthorization();
+          _setupRegistryServiceAuthorization();
           _setupStakingServiceAuthorization();
           _setupInstanceServiceAuthorization();
+          _setupAccountingServiceAuthorization();
           _setupComponentServiceAuthorization();
+          _setupClaimServiceAuthorization();
+          _setupRiskServiceAuthorization();
           _setupDistributionServiceAuthorization();
           _setupPoolServiceAuthorization();
           _setupBundleServiceAuthorization();
+          _setupOracleServiceAuthorization();
+          _setupApplicationServiceAuthorization();
+          _setupPolicyServiceAuthorization();
      }
 
 
      /// @dev registry service authorization.
      /// authorized functions MUST be implemented with a restricted modifier
-     function _setupIRegistryServiceAuthorization()
+     function _setupRegistryServiceAuthorization()
           internal
      {
           IAccess.FunctionInfo[] storage functions;
@@ -96,6 +115,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");
 
@@ -113,11 +133,58 @@ contract ServiceAuthorizationV3
      function _setupInstanceServiceAuthorization()
           internal
      {
-          // TODO cleanup
-          // IAccess.FunctionInfo[] storage functions;
+          IAccess.FunctionInfo[] storage functions;
+          functions = _authorizeForService(INSTANCE(), ALL());
+          _authorize(functions, IInstanceService.createRole.selector, "createRole");
+          _authorize(functions, IInstanceService.setRoleActive.selector, "setRoleActive");
+          _authorize(functions, IInstanceService.grantRole.selector, "grantRole");
+          _authorize(functions, IInstanceService.revokeRole.selector, "revokeRole");
+
+          _authorize(functions, IInstanceService.createTarget.selector, "createTarget");
+          _authorize(functions, IInstanceService.authorizeFunctions.selector, "authorizeFunctions");
+          _authorize(functions, IInstanceService.unauthorizeFunctions.selector, "unauthorizeFunctions");
+          _authorize(functions, IInstanceService.setTargetLocked.selector, "setTargetLocked");
+          _authorize(functions, IInstanceService.setInstanceLocked.selector, "setInstanceLocked");
+
+          _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");
+     }
+
+     /// @dev Accounting service function authorization.
+     function _setupAccountingServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForService(ACCOUNTING(), BUNDLE());
+          _authorize(functions, IAccountingService.increaseBundleBalance.selector, "increaseBundleBalance");
+          _authorize(functions, IAccountingService.decreaseBundleBalance.selector, "decreaseBundleBalance");
+
+          functions = _authorizeForService(ACCOUNTING(), COMPONENT());
+          _authorize(functions, IAccountingService.decreaseComponentFees.selector, "decreaseComponentFees");
+
+          functions = _authorizeForService(ACCOUNTING(), DISTRIBUTION());
+          _authorize(functions, IAccountingService.increaseDistributionBalance.selector, "increaseDistributionBalance");
+          _authorize(functions, IAccountingService.decreaseDistributionBalance.selector, "decreaseDistributionBalance");
+          _authorize(functions, IAccountingService.increaseDistributorBalance.selector, "increaseDistributorBalance");
+          _authorize(functions, IAccountingService.decreaseDistributorBalance.selector, "decreaseDistributorBalance");
+
+          functions = _authorizeForService(ACCOUNTING(), POLICY());
+          _authorize(functions, IAccountingService.increaseProductFees.selector, "increaseProductFees");
+          
+          functions = _authorizeForService(ACCOUNTING(), POOL());
+          _authorize(functions, IAccountingService.increasePoolBalance.selector, "increasePoolBalance");
+          _authorize(functions, IAccountingService.decreasePoolBalance.selector, "decreasePoolBalance");
+          _authorize(functions, IAccountingService.increaseBundleBalanceForPool.selector, "increaseBundleBalanceForPool");
+          _authorize(functions, IAccountingService.decreaseBundleBalanceForPool.selector, "decreaseBundleBalanceForPool");
 
-          // functions = _authorizeForService(INSTANCE(), COMPONENT());
-          // _authorize(functions, IInstanceService.initializeAuthorization.selector, "initializeAuthorization");
      }
 
 
@@ -125,39 +192,64 @@ contract ServiceAuthorizationV3
      function _setupComponentServiceAuthorization()
           internal
      {
-          // TODO cleanup
-          // authz.authorizations = new DomainAuthorization[](4);
-
-          // authz.authorizations[0].domain = POLICY();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increaseProductFees.selector, "increaseProductFees"));
-          // authz.authorizations[0].functions = _functions;
-
-          // authz.authorizations[1].domain = DISTRIBUTION();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increaseDistributionBalance.selector, "increaseDistributionBalance"));
-          // authz.authorizations[1].functions = _functions;
-
-          // authz.authorizations[2].domain = POOL();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increasePoolBalance.selector, "increasePoolBalance"));
-          // authz.authorizations[2].functions = _functions;
-
-          // authz.authorizations[3].domain = BUNDLE();
-          // _functions = new IAccessAdmin.Function[](1);
-          // __authorize(ComponentService.increaseBundleBalance.selector, "increaseBundleBalance"));
-          // authz.authorizations[3].functions = _functions;
+          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.
+     function _setupRiskServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
+          functions = _authorizeForService(RISK(), ALL());
+          _authorize(functions, IRiskService.createRisk.selector, "createRisk");
+          _authorize(functions, IRiskService.updateRisk.selector, "updateRisk");
+          _authorize(functions, IRiskService.updateRiskState.selector, "updateRiskState");
      }
 
      /// @dev Distribution service function authorization.
-     function _setupDistributionServiceAuthorization()
+     function _setupClaimServiceAuthorization()
           internal
      {
           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.
+     function _setupDistributionServiceAuthorization()
+          internal
+     {
+          IAccess.FunctionInfo[] storage functions;
           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");
      }
 
 
@@ -174,6 +266,16 @@ contract ServiceAuthorizationV3
 
           functions = _authorizeForService(POOL(), CLAIM());
           _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");
      }
 
 
@@ -189,7 +291,6 @@ contract ServiceAuthorizationV3
           _authorize(functions, IBundleService.close.selector, "close");
           _authorize(functions, IBundleService.lockCollateral.selector, "lockCollateral");
           _authorize(functions, IBundleService.releaseCollateral.selector, "releaseCollateral");
-          _authorize(functions, IBundleService.unlinkPolicy.selector, "unlinkPolicy");
 
           functions = _authorizeForService(BUNDLE(), ALL());
           _authorize(functions, IBundleService.create.selector, "create");
@@ -197,7 +298,47 @@ contract ServiceAuthorizationV3
           _authorize(functions, IBundleService.lock.selector, "lock");
           _authorize(functions, IBundleService.unlock.selector, "unlock");
           _authorize(functions, IBundleService.setFee.selector, "setFee");
-          _authorize(functions, IBundleService.withdrawBundleFees.selector, "withdrawBundleFees");
+     }
+
+     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.adjustActivation.selector, "adjustActivation");
+          _authorize(functions, IPolicyService.expire.selector, "expire");
+          _authorize(functions, IPolicyService.expirePolicy.selector, "expirePolicy");
+          _authorize(functions, IPolicyService.close.selector, "close");
+
      }
 }
 

package/contracts/registry/TokenRegistry.sol

@@ -3,20 +3,16 @@ pragma solidity ^0.8.20;
 
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-
-import {REGISTRY} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.sol";
-
-import {IRegisterable} from "../shared/IRegisterable.sol";
 
 import {IRegistry} from "./IRegistry.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+
 import {ReleaseRegistry} from "./ReleaseRegistry.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
+import {VersionPart} from "../type/Version.sol";
 
-
-/// @title contract to register token per GIF major release.
+/// @dev The TokenRegistry contract is used to whitelist/manage ERC-20 of tokens per major release.
+/// Only whitelisted tokens can be used as default tokens for products, distribution and pools components.
 contract TokenRegistry is
     AccessManaged,
     IRegistryLinked
@@ -37,10 +33,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;
     }
 
@@ -68,7 +67,7 @@ contract TokenRegistry is
         setAuthority(authority);
         
         _registry = registry;
-        _dipToken = dipToken;
+        _dipToken = _verifyOnchainToken(address(dipToken));
 
         // register dip token
         uint256 chainId = block.chainid;
@@ -212,13 +211,13 @@ contract TokenRegistry is
         return _tokenInfo[chainId][token].chainId > 0;
     }
 
-    /// @dev returns true iff both the token is active for the specfied version and the global token state is active
-    function isActive(uint256 chainId, address token, VersionPart majorVersion) external view returns (bool) {
+    /// @dev returns true iff both the token is active for the specfied release and the global token state is active
+    function isActive(uint256 chainId, address token, VersionPart release) external view returns (bool) {
         if(!_tokenInfo[chainId][token].active) {
             return false;
         }
 
-        return _active[chainId][token][majorVersion];
+        return _active[chainId][token][release];
     }
 
     function getDipTokenAddress() external view returns (address) {

package/contracts/shared/Component.sol

@@ -1,23 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import {Amount, AmountLib} from "../type/Amount.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 {NftId, NftIdLib} from "../type/NftId.sol";
+import {NftId} from "../type/NftId.sol";
 import {ObjectType, COMPONENT} from "../type/ObjectType.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {VersionPartLib} from "../type/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+
 
 abstract contract Component is
-    AccessManagedUpgradeable,
     Registerable,
     IComponent
 {
@@ -26,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;
@@ -40,18 +37,20 @@ abstract contract Component is
         _;
     }
 
+
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
         assembly {
             $.slot := COMPONENT_LOCATION_V1
         }
     }
 
+
     function _initializeComponent(
         address authority,
         address registry,
         NftId parentNftId,
         string memory name,
-        address token,
         ObjectType componentType,
         bool isInterceptor,
         address initialOwner,
@@ -62,15 +61,12 @@ abstract contract Component is
         virtual
         onlyInitializing()
     {
-        if (token == address(0)) {
-            revert ErrorComponentTokenAddressZero();
-        }
-
         if (bytes(name).length == 0) {
             revert ErrorComponentNameLengthZero();
         }
 
-        _initializeRegisterable(
+        __Registerable_init(
+            authority,
             registry, 
             parentNftId, 
             componentType, 
@@ -78,12 +74,9 @@ abstract contract Component is
             initialOwner, 
             registryData);
 
-        __AccessManaged_init(authority);
-
         // set component state
         ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
-        $._token = IERC20Metadata(token);
         $._isInterceptor = isInterceptor;
         $._data = componentData;
         $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
@@ -93,35 +86,6 @@ abstract contract Component is
     }
 
 
-    function approveTokenHandler(IERC20Metadata token, Amount amount)
-        public
-        onlyOwner()
-    {
-        _approveTokenHandler(token, amount);
-    }
-
-
-    // TODO cleanup
-    // /// @dev Approves the component's token hander to spend tokens up to the specified limit.
-    // /// When the spending limit amount equals AmountLib.max it is set to type(uint256).max.
-    // function approveTokenHandler(address token, Amount spendingLimitAmount)
-    //     public
-    //     virtual
-    //     onlyOwner
-    // {
-    //     _approveTokenHandler(token, spendingLimitAmount);
-    // }
-
-
-    // function setWallet(address newWallet)
-    //     external
-    //     virtual
-    //     override
-    //     onlyOwner
-    // {
-    //     _setWallet(newWallet);
-    // }
-
     /// @dev callback function for nft transfers
     /// may only be called by chain nft contract.
     /// override internal function _nftTransferFrom to implement custom behaviour
@@ -142,13 +106,17 @@ 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) {
         return getComponentInfo().name;
     }
 
+    function getVersion() public view virtual returns (Version version) {
+        return VersionLib.toVersion(1, 0, 0);
+    }
+
     function getComponentInfo() public virtual view returns (IComponents.ComponentInfo memory info) {
         if (isRegistered()) {
             return _getComponentInfo();
@@ -178,6 +146,9 @@ abstract contract Component is
     }
 
 
+    /// @dev Approves token hanlder to spend up to the specified amount of tokens.
+    /// Reverts if component wallet is not token handler itself.
+    /// Only component owner (nft holder) is authorizes to call this function.
     function _approveTokenHandler(IERC20Metadata token, Amount amount)
         internal
         virtual
@@ -193,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
@@ -207,6 +182,13 @@ abstract contract Component is
         _getComponentStorage()._componentService.setWallet(newWallet);
     }
 
+    function _setLocked(bool locked)
+        internal
+        virtual
+    {
+        _getComponentStorage()._componentService.setLocked(locked);
+    }
+
 
     /// @dev 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
@@ -215,7 +197,6 @@ abstract contract Component is
         
         return IComponents.ComponentInfo({
             name: $._name,
-            token: $._token,
             tokenHandler: TokenHandler(address(0)),
             data: $._data // user specific component data
         });