@etherisc/gif-next 0.0.2-b89a442-717 → 0.0.2-b8da656-306

package/contracts/registry/{ReleaseManager.sol → ReleaseRegistry.sol}

@@ -32,9 +32,7 @@ import {Registry} from "./Registry.sol";
 import {TokenRegistry} from "./TokenRegistry.sol";
 import {ReleaseLifecycle} from "./ReleaseLifecycle.sol";
 
-// TODO rename to something that does not end with 'Manager' 
-// everywhere else *Manager points to an upgradeable contract
-contract ReleaseManager is 
+contract ReleaseRegistry is 
     AccessManaged,
     ReleaseLifecycle, 
     IRegistryLinked
@@ -49,45 +47,45 @@ contract ReleaseManager is
     event LogReleaseEnabled(VersionPart version);
 
     // constructor
-    error ErrorReleaseManagerNotRegistry(Registry registry);
+    error ErrorReleaseRegistryNotRegistry(Registry registry);
 
     // createNextRelease
-    error ErrorReleaseManagerReleaseCreationDisallowed(VersionPart version, StateId currentStateId);
+    error ErrorReleaseRegistryReleaseCreationDisallowed(VersionPart version, StateId currentStateId);
 
     // prepareRelease
-    error ErrorReleaseManagerReleasePreparationDisallowed(VersionPart version, StateId currentStateId);
-    error ErrorReleaseManagerReleaseAlreadyPrepared(VersionPart version, StateId currentStateId);
-    error ErrorReleaseManagerVersionMismatch(VersionPart expected, VersionPart actual);
-    error ErrorReleaseManagerNoDomains(VersionPart version);
+    error ErrorReleaseRegistryReleasePreparationDisallowed(VersionPart version, StateId currentStateId);
+    error ErrorReleaseRegistryReleaseAlreadyPrepared(VersionPart version, StateId currentStateId);
+    error ErrorReleaseRegistryVersionMismatch(VersionPart expected, VersionPart actual);
+    error ErrorReleaseRegistryNoDomains(VersionPart version);
 
     // registerService
-    error ErrorReleaseManagerNoServiceRegistrationExpected();
-    error ErrorReleaseManagerServiceRegistrationDisallowed(StateId currentStateId);
-    error ErrorReleaseManagerServiceDomainMismatch(ObjectType expectedDomain, ObjectType actualDomain);
-    error ErrorReleaseManagerNotService(address notService);
-    error ErrorReleaseManagerServiceAddressMismatch(address expected, address actual);
+    error ErrorReleaseRegistryNoServiceRegistrationExpected();
+    error ErrorReleaseRegistryServiceRegistrationDisallowed(StateId currentStateId);
+    error ErrorReleaseRegistryServiceDomainMismatch(ObjectType expectedDomain, ObjectType actualDomain);
+    error ErrorReleaseRegistryNotService(address notService);
+    error ErrorReleaseRegistryServiceAddressMismatch(address expected, address actual);
 
     // activateNextRelease
-    error ErrorReleaseManagerReleaseActivationDisallowed(VersionPart releaseVersion, StateId currentStateId);
-    error ErrorReleaseManagerReleaseNotCreated(VersionPart releaseVersion);
-    error ErrorReleaseManagerReleaseRegistrationNotFinished(VersionPart releaseVersion, uint awaitingRegistration);
-    error ErrorReleaseManagerReleaseAlreadyActivated(VersionPart releaseVersion);
+    error ErrorReleaseRegistryReleaseActivationDisallowed(VersionPart releaseVersion, StateId currentStateId);
+    error ErrorReleaseRegistryReleaseNotCreated(VersionPart releaseVersion);
+    error ErrorReleaseRegistryReleaseRegistrationNotFinished(VersionPart releaseVersion, uint awaitingRegistration);
+    error ErrorReleaseRegistryReleaseAlreadyActivated(VersionPart releaseVersion);
 
     // disableRelease
-    error ErrorReleaseManagerReleaseNotActivated(VersionPart releaseVersion);
-    error ErrorReleaseManagerReleaseAlreadyDisabled(VersionPart releaseVersion);
+    error ErrorReleaseRegistryReleaseNotActivated(VersionPart releaseVersion);
+    error ErrorReleaseRegistryReleaseAlreadyDisabled(VersionPart releaseVersion);
 
     // _verifyService
-    error ErrorReleaseManagerServiceReleaseAuthorityMismatch(IService service, address serviceAuthority, address releaseAuthority);
-    error ErrorReleaseManagerServiceReleaseVersionMismatch(IService service, VersionPart serviceVersion, VersionPart releaseVersion);
+    error ErrorReleaseRegistryServiceReleaseAuthorityMismatch(IService service, address serviceAuthority, address releaseAuthority);
+    error ErrorReleaseRegistryServiceReleaseVersionMismatch(IService service, VersionPart serviceVersion, VersionPart releaseVersion);
 
     // _verifyServiceInfo
-    error ErrorReleaseManagerServiceInfoAddressInvalid(IService service, address expected);
-    error ErrorReleaseManagerServiceInfoInterceptorInvalid(IService service, bool isInterceptor);
-    error ErrorReleaseManagerServiceInfoTypeInvalid(IService service, ObjectType expected, ObjectType found);
-    error ErrorReleaseManagerServiceInfoOwnerInvalid(IService service, address expected, address found);
-    error ErrorReleaseManagerServiceSelfRegistration(IService service);
-    error ErrorReleaseManagerServiceOwnerRegistered(IService service, address owner);
+    error ErrorReleaseRegistryServiceInfoAddressInvalid(IService service, address expected);
+    error ErrorReleaseRegistryServiceInfoInterceptorInvalid(IService service, bool isInterceptor);
+    error ErrorReleaseRegistryServiceInfoTypeInvalid(IService service, ObjectType expected, ObjectType found);
+    error ErrorReleaseRegistryServiceInfoOwnerInvalid(IService service, address expected, address found);
+    error ErrorReleaseRegistryServiceSelfRegistration(IService service);
+    error ErrorReleaseRegistryServiceOwnerRegistered(IService service, address owner);
 
     Seconds public constant MIN_DISABLE_DELAY = Seconds.wrap(60 * 24 * 365); // 1 year
 
@@ -115,7 +113,7 @@ contract ReleaseManager is
     {
         // TODO move this part to RegistryLinked constructor
         if(!_isRegistry(address(registry))) {
-            revert ErrorReleaseManagerNotRegistry(registry);
+            revert ErrorReleaseRegistryNotRegistry(registry);
         }
 
         setAuthority(registry.getAuthority());
@@ -167,7 +165,7 @@ contract ReleaseManager is
 
         // verify release in state SCHEDULED
         if (!isValidTransition(RELEASE(), _state[version], DEPLOYING())) {
-            revert ErrorReleaseManagerReleasePreparationDisallowed(version, _state[version]);
+            revert ErrorReleaseRegistryReleasePreparationDisallowed(version, _state[version]);
         }
 
         _state[version] = DEPLOYING();
@@ -175,19 +173,19 @@ contract ReleaseManager is
         // verify authorizaion contract release matches with expected version
         VersionPart releaseVersion = serviceAuthorization.getRelease();
         if (releaseVersion != version) {
-            revert ErrorReleaseManagerVersionMismatch(version, releaseVersion);
+            revert ErrorReleaseRegistryVersionMismatch(version, releaseVersion);
         }
 
 
         // sanity check to ensure service domain list is not empty
         uint256 serviceDomainsCount = serviceAuthorization.getServiceDomains().length;
         if (serviceDomainsCount == 0) {
-            revert ErrorReleaseManagerNoDomains(version);
+            revert ErrorReleaseRegistryNoDomains(version);
         }
 
         // verify prepareNextRelease is only called once per release
         if(_servicesToRegister > 0) {
-            revert ErrorReleaseManagerReleaseAlreadyPrepared(version, _state[version]);
+            revert ErrorReleaseRegistryReleaseAlreadyPrepared(version, _state[version]);
         }
 
         _servicesToRegister = serviceDomainsCount;
@@ -196,7 +194,6 @@ contract ReleaseManager is
         emit LogReleaseCreation(version, releaseSalt);
     }
 
-    // TODO this function can have 0 args -> use stored addresses from prepareNextRelease()
     function registerService(IService service) 
         external
         restricted // GIF_MANAGER_ROLE
@@ -208,14 +205,14 @@ contract ReleaseManager is
         // verify release in state DEPLOYING
         if (!isValidTransition(RELEASE(), state, DEPLOYING())) {
             // TOOD name must represent failed state transition
-            revert ErrorReleaseManagerServiceRegistrationDisallowed(state);
+            revert ErrorReleaseRegistryServiceRegistrationDisallowed(state);
         }
 
         _state[releaseVersion] = DEPLOYING();
 
         // not all services are registered
         if (_servicesToRegister == _registeredServices) {
-            revert ErrorReleaseManagerNoServiceRegistrationExpected();
+            revert ErrorReleaseRegistryNoServiceRegistrationExpected();
         }
 
         // service can work with release manager
@@ -228,23 +225,30 @@ contract ReleaseManager is
         // service domain matches defined in release config
         ObjectType expectedDomain = _serviceAuthorization[releaseVersion].getServiceDomain(_registeredServices);
         if (serviceDomain != expectedDomain) {
-            revert ErrorReleaseManagerServiceDomainMismatch(expectedDomain, serviceDomain);
+            revert ErrorReleaseRegistryServiceDomainMismatch(expectedDomain, serviceDomain);
         }
 
         // register service with registry
+        // !!! TODO MUST call registry at the end of this function
         nftId = _registry.registerService(info, serviceVersion, serviceDomain);
         service.linkToRegisteredNftId();
         _registeredServices++;
 
         // setup service authorization
+        // !!! TODO service A can call service B while release is not active
         _admin.authorizeService(
             _serviceAuthorization[releaseVersion], 
-            service);
+            service,
+            serviceDomain,
+            serviceVersion);
 
-        // TODO consider to extend this to REGISTRY
         // special roles for registry/staking/pool service
-        if (serviceDomain == STAKING() || serviceDomain == POOL()) {
-            // TODO rename to grantServiceDomainRole()
+        // !!! TODO registry service allowed to call registry while release is not activated (same for staking/pool service and staking)
+        if (
+            serviceDomain == REGISTRY() ||
+            serviceDomain == STAKING() ||
+            serviceDomain == POOL()) 
+        {
             _admin.grantServiceRoleForAllVersions(service, serviceDomain);
         }
     }
@@ -260,18 +264,18 @@ contract ReleaseManager is
 
         // verify release in state DEPLOYING
         if (!isValidTransition(RELEASE(), state, newState)) {
-            revert ErrorReleaseManagerReleaseActivationDisallowed(version, state);
+            revert ErrorReleaseRegistryReleaseActivationDisallowed(version, state);
         }
 
         // release fully deployed
         if(_registeredServices < _servicesToRegister) {
-            revert ErrorReleaseManagerReleaseRegistrationNotFinished(version, _servicesToRegister - _registeredServices);
+            revert ErrorReleaseRegistryReleaseRegistrationNotFinished(version, _servicesToRegister - _registeredServices);
         }
 
         // release exists, registry service MUST exist
         address service = _registry.getServiceAddress(REGISTRY(), version);
         if(service == address(0)) {
-            revert ErrorReleaseManagerReleaseNotCreated(version);
+            revert ErrorReleaseRegistryReleaseNotCreated(version);
         }
 
         _latest = version;
@@ -293,7 +297,7 @@ contract ReleaseManager is
 
         // verify release in state ACTIVE
         if (!isValidTransition(RELEASE(), state, newState)) {
-            revert ErrorReleaseManagerReleaseActivationDisallowed(version, state);
+            revert ErrorReleaseRegistryReleaseActivationDisallowed(version, state);
         }
 
         // TODO come up with a substitute
@@ -316,7 +320,7 @@ contract ReleaseManager is
 
         // verify release in state PAUSED
         if (!isValidTransition(RELEASE(), state, newState)) {
-            revert ErrorReleaseManagerReleaseActivationDisallowed(version, state);
+            revert ErrorReleaseRegistryReleaseActivationDisallowed(version, state);
         }
 
         // TODO come up with a substitute
@@ -401,7 +405,7 @@ contract ReleaseManager is
         )
     {
         if(!service.supportsInterface(type(IService).interfaceId)) {
-            revert ErrorReleaseManagerNotService(address(service));
+            revert ErrorReleaseRegistryNotService(address(service));
         }
 
         address owner = msg.sender;
@@ -417,14 +421,14 @@ contract ReleaseManager is
 
         // IMPORTANT: can not guarantee service access is actually controlled by authority
         if(serviceAuthority != expectedAuthority) {
-            revert ErrorReleaseManagerServiceReleaseAuthorityMismatch(
+            revert ErrorReleaseRegistryServiceReleaseAuthorityMismatch(
                 service,
                 serviceAuthority,
                 expectedAuthority);
         }
 
         if(serviceVersion != releaseVersion) {
-            revert ErrorReleaseManagerServiceReleaseVersionMismatch(
+            revert ErrorReleaseRegistryServiceReleaseVersionMismatch(
                 service,
                 serviceVersion,
                 releaseVersion);            
@@ -441,29 +445,29 @@ contract ReleaseManager is
         view
     {
         if(info.objectAddress != address(service)) {
-            revert ErrorReleaseManagerServiceInfoAddressInvalid(service, address(service));
+            revert ErrorReleaseRegistryServiceInfoAddressInvalid(service, address(service));
         }
 
         if(info.isInterceptor != false) { // service is never interceptor
-            revert ErrorReleaseManagerServiceInfoInterceptorInvalid(service, info.isInterceptor);
+            revert ErrorReleaseRegistryServiceInfoInterceptorInvalid(service, info.isInterceptor);
         }
 
         if(info.objectType != SERVICE()) {
-            revert ErrorReleaseManagerServiceInfoTypeInvalid(service, SERVICE(), info.objectType);
+            revert ErrorReleaseRegistryServiceInfoTypeInvalid(service, SERVICE(), info.objectType);
         }
 
         address owner = info.initialOwner;
 
         if(owner != expectedOwner) { // registerable owner protection
-            revert ErrorReleaseManagerServiceInfoOwnerInvalid(service, expectedOwner, owner); 
+            revert ErrorReleaseRegistryServiceInfoOwnerInvalid(service, expectedOwner, owner); 
         }
 
         if(owner == address(service)) {
-            revert ErrorReleaseManagerServiceSelfRegistration(service);
+            revert ErrorReleaseRegistryServiceSelfRegistration(service);
         }
         
         if(_registry.isRegistered(owner)) { 
-            revert ErrorReleaseManagerServiceOwnerRegistered(service, owner);
+            revert ErrorReleaseRegistryServiceOwnerRegistered(service, owner);
         }
     }
 
@@ -477,7 +481,7 @@ contract ReleaseManager is
         // TODO try catch and return false in case of revert
         // or just panic
         // check if contract returns a zero nft id for its own address
-        if (IRegistry(registryAddress).getNftId(registryAddress).eqz()) {
+        if (IRegistry(registryAddress).getNftIdForAddress(registryAddress).eqz()) {
             return false;
         }
 

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -2,14 +2,12 @@
 pragma solidity ^0.8.20;
 
 import {
-     ALL, REGISTRY, SERVICE, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKE, STAKING, PRICE
+     ALL, REGISTRY, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKING, PRICE
 } from "../../contracts/type/ObjectType.sol";
 
-import {ComponentService} from "../shared/ComponentService.sol";
 import {IAccess} from "../authorization/IAccess.sol";
 import {IBundleService} from "../pool/IBundleService.sol";
 import {IDistributionService} from "../distribution/IDistributionService.sol";
-import {InstanceService} from "../instance/InstanceService.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPoolService} from "../pool/IPoolService.sol";
 import {IStakingService} from "../staking/IStakingService.sol";
@@ -39,9 +37,9 @@ contract ServiceAuthorizationV3
           _authorizeDomain(POOL(), address(8));
           _authorizeDomain(ORACLE(), address(9));
           _authorizeDomain(PRODUCT(), address(10));
-          _authorizeDomain(CLAIM(), address(11));
-          _authorizeDomain(APPLICATION(), address(12));
-          _authorizeDomain(POLICY(), address(13));
+          _authorizeDomain(POLICY(), address(11));
+          _authorizeDomain(CLAIM(), address(12));
+          _authorizeDomain(APPLICATION(), address(13));
      }
 
 
@@ -69,14 +67,14 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(REGISTRY(), APPLICATION());
           _authorize(functions, IRegistryService.registerPolicy.selector, "registerPolicy");
 
-          functions = _authorizeForService(REGISTRY(), POOL());
-          _authorize(functions, IRegistryService.registerPool.selector, "registerPool");
+          // functions = _authorizeForService(REGISTRY(), POOL());
+          // _authorize(functions, IRegistryService.registerPool.selector, "registerPool");
 
           functions = _authorizeForService(REGISTRY(), BUNDLE());
           _authorize(functions, IRegistryService.registerBundle.selector, "registerBundle");
 
           functions = _authorizeForService(REGISTRY(), DISTRIBUTION());
-          _authorize(functions, IRegistryService.registerDistribution.selector, "registerDistribution");
+          // _authorize(functions, IRegistryService.registerDistribution.selector, "registerDistribution");
           _authorize(functions, IRegistryService.registerDistributor.selector, "registerDistributor");
 
           functions = _authorizeForService(REGISTRY(), COMPONENT());
@@ -88,8 +86,8 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(REGISTRY(), STAKING());
           _authorize(functions, IRegistryService.registerStake.selector, "registerStake");
 
-          functions = _authorizeForService(REGISTRY(), PRODUCT());
-          _authorize(functions, IRegistryService.registerProduct.selector, "registerProduct");
+          // functions = _authorizeForService(REGISTRY(), PRODUCT());
+          // _authorize(functions, IRegistryService.registerProduct.selector, "registerProduct");
      }
 
 
@@ -163,6 +161,7 @@ contract ServiceAuthorizationV3
 
           functions = _authorizeForService(DISTRIBUTION(), POLICY());
           _authorize(functions, IDistributionService.processSale.selector, "processSale");
+          _authorize(functions, IDistributionService.processReferral.selector, "processReferral");
      }
 
 
@@ -175,11 +174,10 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(POOL(), POLICY());
           _authorize(functions, IPoolService.lockCollateral.selector, "lockCollateral");
           _authorize(functions, IPoolService.releaseCollateral.selector, "releaseCollateral");
-          _authorize(functions, IPoolService.reduceCollateral.selector, "reduceCollateral");
           _authorize(functions, IPoolService.processSale.selector, "processSale");
 
           functions = _authorizeForService(POOL(), CLAIM());
-          _authorize(functions, IPoolService.reduceCollateral.selector, "reduceCollateral");
+          _authorize(functions, IPoolService.processPayout.selector, "processPayout");
      }
 
 

package/contracts/registry/TokenRegistry.sol

@@ -12,7 +12,7 @@ import {IRegisterable} from "../shared/IRegisterable.sol";
 
 import {IRegistry} from "./IRegistry.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
-import {ReleaseManager} from "./ReleaseManager.sol";
+import {ReleaseRegistry} from "./ReleaseRegistry.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
 
 
@@ -49,7 +49,7 @@ contract TokenRegistry is
     TokenInfo [] internal _token;
 
     IRegistry internal _registry;
-    ReleaseManager internal _releaseManager;
+    ReleaseRegistry internal _releaseRegistry;
     IERC20Metadata internal _dipToken;
 
     /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)

package/contracts/shared/Component.sol

@@ -6,7 +6,7 @@ import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessMana
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import {Amount} from "../type/Amount.sol";
+import {Amount, AmountLib} from "../type/Amount.sol";
 import {IComponent} from "./IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
@@ -26,7 +26,6 @@ abstract contract Component is
     struct ComponentStorage {
         string _name; // unique (per instance) component name
         IERC20Metadata _token; // token for this component
-        TokenHandler _tokenHandler;
         address _wallet;
         bool _isInterceptor;
         bytes _data;
@@ -40,6 +39,12 @@ abstract contract Component is
         _;
     }
 
+    modifier onlyNftOwner(NftId nftId) {
+        if(msg.sender != getRegistry().ownerOf(nftId)) {
+            revert ErrorNftOwnableNotOwner(msg.sender);
+        }
+        _;
+    }
 
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
         assembly {
@@ -47,7 +52,7 @@ abstract contract Component is
         }
     }
 
-    function initializeComponent(
+    function _initializeComponent(
         address authority,
         address registry,
         NftId parentNftId,
@@ -59,11 +64,11 @@ abstract contract Component is
         bytes memory registryData, // writeonly data that will saved in the object info record of the registry
         bytes memory componentData // other component specific data
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegisterable(registry, parentNftId, componentType, isInterceptor, initialOwner, registryData);
+        _initializeRegisterable(registry, parentNftId, componentType, isInterceptor, initialOwner, registryData);
         __AccessManaged_init(authority);
 
         if (token == address(0)) {
@@ -78,13 +83,12 @@ abstract contract Component is
         ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
         $._token = IERC20Metadata(token);
-        $._tokenHandler = TokenHandler(address(0));
         $._wallet = address(this);
         $._isInterceptor = isInterceptor;
         $._data = componentData;
 
-        registerInterface(type(IAccessManaged).interfaceId);
-        registerInterface(type(IComponent).interfaceId);
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IComponent).interfaceId);
     }
 
 
@@ -105,11 +109,11 @@ abstract contract Component is
             revert ErrorComponentWalletNotComponent();
         }
 
+        emit LogComponentTokenHandlerApproved(address(getTokenHandler()), spendingLimitAmount);
+
         IERC20Metadata(token).approve(
             address(getTokenHandler()),
             spendingLimitAmount.toInt());
-
-        emit LogComponentTokenHandlerApproved(address(getTokenHandler()), spendingLimitAmount);
     }
 
     function setWallet(address newWallet)
@@ -120,34 +124,22 @@ abstract contract Component is
     {
         // checks
         address currentWallet = getWallet();
-        IERC20Metadata token = getToken();
-        uint256 currentBalance = token.balanceOf(currentWallet);
-
-        if (currentBalance > 0) {
-            if (currentWallet == address(this)) {
-                // move tokens from component smart contract to external wallet
-            } else {
-                // move tokens from external wallet to component smart contract or another external wallet
-                uint256 allowance = token.allowance(currentWallet, address(this));
-                if (allowance < currentBalance) {
-                    revert ErrorComponentWalletAllowanceTooSmall(currentWallet, newWallet, allowance, currentBalance);
-                }
-            }
-        }
+        uint256 currentBalance = getToken().balanceOf(currentWallet);
 
         // effects
         _setWallet(newWallet);
 
         // interactions
         if (currentBalance > 0) {
-            // transfer tokens from current wallet to new wallet
+            // move tokens from old to new wallet 
+            emit LogComponentWalletTokensTransferred(currentWallet, newWallet, currentBalance);
+
             if (currentWallet == address(this)) {
-                // transferFrom requires self allowance too
-                token.approve(address(this), currentBalance);
+                // transfer from the component requires an allowance
+                getTokenHandler().distributeTokens(currentWallet, newWallet, AmountLib.toAmount(currentBalance));
+            } else {
+                getTokenHandler().collectTokens(currentWallet, newWallet, AmountLib.toAmount(currentBalance));
             }
-            
-            SafeERC20.safeTransferFrom(token, currentWallet, newWallet, currentBalance);
-            emit LogComponentWalletTokensTransferred(currentWallet, newWallet, currentBalance);
         }
     }
 
@@ -214,7 +206,7 @@ abstract contract Component is
 
 
     function isRegistered() public virtual view returns (bool) {
-        return getRegistry().getNftId(address(this)).gtz();
+        return getRegistry().getNftIdForAddress(address(this)).gtz();
     }
 
 
@@ -253,29 +245,24 @@ abstract contract Component is
     }
 
 
-    /// @dev for component contracts that hold its own component information 
-    /// this function creates and sets a token hanlder for the components tokens
-    function _createAndSetTokenHandler()
-        internal
-    {
-        ComponentStorage storage $ = _getComponentStorage();
-        $._tokenHandler = new TokenHandler(address($._token));
-    }
-
-
     /// @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
     function _getComponentInfo() internal virtual view returns (IComponents.ComponentInfo memory info) {
         ComponentStorage storage $ = _getComponentStorage();
-
+        
         return IComponents.ComponentInfo({
             name: $._name,
             productNftId: NftIdLib.zero(),
             token: $._token,
-            tokenHandler: $._tokenHandler,
+            tokenHandler: TokenHandler(address(0)),
             wallet: $._wallet, // initial wallet address
             data: $._data // user specific component data
         });
     }
 
+    function _approveTokenHandler(uint256 amount) internal {
+        ComponentStorage storage $ = _getComponentStorage();
+        $._token.approve(address(getComponentInfo().tokenHandler), amount);
+    }
+
 }