@etherisc/gif-next 0.0.2-f634e5c-828 → 0.0.2-f689687-279

package/contracts/shared/ComponentService.sol

@@ -3,11 +3,7 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-import {AccessAdmin} from "../authorization/AccessAdmin.sol";
-import {Amount, AmountLib} from "../type/Amount.sol";
-import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {ContractLib} from "../shared/ContractLib.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
+import {IAccountingService} from "../accounting/IAccountingService.sol";
 import {IComponent} from "../shared/IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "./IComponentService.sol";
@@ -27,8 +23,8 @@ import {Amount, AmountLib} from "../type/Amount.sol";
 import {ContractLib} from "../shared/ContractLib.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {KEEP_STATE} from "../type/StateId.sol";
-import {NftId} from "../type/NftId.sol";
-import {ObjectType, REGISTRY, BUNDLE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, INSTANCE, ORACLE, POOL, PRODUCT, STAKING} from "../type/ObjectType.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {ObjectType, ACCOUNTING, REGISTRY, COMPONENT, DISTRIBUTION, INSTANCE, ORACLE, POOL, PRODUCT} from "../type/ObjectType.sol";
 import {Service} from "../shared/Service.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {TokenHandlerDeployerLib} from "../shared/TokenHandlerDeployerLib.sol";
@@ -42,6 +38,7 @@ contract ComponentService is
     bool private constant INCREASE = true;
     bool private constant DECREASE = false;
 
+    IAccountingService private _accountingService;
     IRegistryService private _registryService;
     IInstanceService private _instanceService;
 
@@ -79,12 +76,13 @@ contract ComponentService is
         initializer()
     {
         (
-            address registryAddress,
-            address authority
+            address authority,
+            address registry
         ) = abi.decode(data, (address, address));
 
-        _initializeService(registryAddress, authority, owner);
+        __Service_init(authority, registry, owner);
 
+        _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
         _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
 
@@ -132,24 +130,6 @@ contract ComponentService is
     }
 
 
-    function approveStakingTokenHandler(
-        IERC20Metadata token,
-        Amount amount
-    )
-        external
-        virtual
-    {
-        // checks
-        ContractLib.getAndVerifyStaking(
-            getRegistry(),
-            msg.sender); // only active
-
-        // effects
-        TokenHandler tokenHandler = IComponent(msg.sender).getTokenHandler();
-        tokenHandler.approve(token, amount);
-    }
-
-
     function setWallet(address newWallet)
         external
         virtual
@@ -185,35 +165,52 @@ contract ComponentService is
         _setLocked(instance.getInstanceAdmin(), componentAddress, locked);
     }
 
+    /// @inheritdoc IComponentService
     function withdrawFees(Amount amount)
         external
         virtual
         returns (Amount withdrawnAmount)
     {
+        // checks
         (NftId componentNftId, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
-        IComponents.ComponentInfo memory info = instance.getInstanceReader().getComponentInfo(componentNftId);
-        address componentWallet = info.tokenHandler.getWallet();
+        InstanceReader instanceReader = instance.getInstanceReader();
 
         // determine withdrawn amount
+        Amount maxAvailableAmount = instanceReader.getFeeAmount(componentNftId);
         withdrawnAmount = amount;
-        if (withdrawnAmount.gte(AmountLib.max())) {
-            withdrawnAmount = instance.getInstanceReader().getFeeAmount(componentNftId);
-        } else if (withdrawnAmount.eqz()) {
+
+        // max amount -> withraw all available fees
+        if (amount == AmountLib.max()) {
+            withdrawnAmount = maxAvailableAmount;
+        }
+
+        // check modified withdrawn amount
+        if (withdrawnAmount.eqz()) {
             revert ErrorComponentServiceWithdrawAmountIsZero();
-        } else {
-            Amount withdrawLimit = instance.getInstanceReader().getFeeAmount(componentNftId);
-            if (withdrawnAmount.gt(withdrawLimit)) {
-                revert ErrorComponentServiceWithdrawAmountExceedsLimit(withdrawnAmount, withdrawLimit);
-            }
+        } else if (withdrawnAmount > maxAvailableAmount) {
+            revert ErrorComponentServiceWithdrawAmountExceedsLimit(withdrawnAmount, maxAvailableAmount);
         }
 
+        // effects
         // decrease fee counters by withdrawnAmount
-        _changeTargetBalance(DECREASE, instance.getInstanceStore(), componentNftId, AmountLib.zero(), withdrawnAmount);
+        _accountingService.decreaseComponentFees(
+            instance.getInstanceStore(), 
+            componentNftId, 
+            withdrawnAmount);
         
-        // transfer amount to component owner
         address componentOwner = getRegistry().ownerOf(componentNftId);
-        emit LogComponentServiceComponentFeesWithdrawn(componentNftId, componentOwner, address(info.token), withdrawnAmount);
-        info.tokenHandler.distributeTokens(componentWallet, componentOwner, withdrawnAmount);
+        TokenHandler tokenHandler = instanceReader.getTokenHandler(componentNftId);
+        emit LogComponentServiceComponentFeesWithdrawn(
+            componentNftId, 
+            componentOwner, 
+            address(tokenHandler.TOKEN()), 
+            withdrawnAmount);
+
+        // interactions
+        // transfer amount to component owner
+        tokenHandler.pushFeeToken(
+            componentOwner, 
+            withdrawnAmount);
     }
 
 
@@ -235,14 +232,22 @@ contract ComponentService is
 
         // get product
         IProductComponent product = IProductComponent(productAddress);
+        
+        IComponents.ProductInfo memory initialProductInfo = product.getInitialProductInfo();
+        // force initialization of linked components with empty values to 
+        // ensure no components are linked upon initialization of the product
+        initialProductInfo.poolNftId = NftIdLib.zero();
+        initialProductInfo.distributionNftId = NftIdLib.zero();
+        initialProductInfo.oracleNftId = new NftId[](initialProductInfo.expectedNumberOfOracles);
 
         // create info
         instanceStore.createProduct(
             productNftId, 
-            product.getInitialProductInfo());
+            initialProductInfo);
 
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(product);
+        instanceStore.createFee(
+            productNftId, 
+            product.getInitialFeeInfo());
     }
 
 
@@ -255,54 +260,29 @@ contract ComponentService is
         nonReentrant()
     {
         (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
-        IComponents.ProductInfo memory productInfo = instance.getInstanceReader().getProductInfo(productNftId);
+        IComponents.FeeInfo memory feeInfo = instance.getInstanceReader().getFeeInfo(productNftId);
         bool feesChanged = false;
 
         // update product fee if required
-        if(!FeeLib.eq(productInfo.productFee, productFee)) {
-            _logUpdateFee(productNftId, "ProductFee", productInfo.productFee, productFee);
-            productInfo.productFee = productFee;
+        if(!FeeLib.eq(feeInfo.productFee, productFee)) {
+            _logUpdateFee(productNftId, "ProductFee", feeInfo.productFee, productFee);
+            feeInfo.productFee = productFee;
             feesChanged = true;
         }
 
         // update processing fee if required
-        if(!FeeLib.eq(productInfo.processingFee, processingFee)) {
-            _logUpdateFee(productNftId, "ProcessingFee", productInfo.processingFee, processingFee);
-            productInfo.processingFee = processingFee;
+        if(!FeeLib.eq(feeInfo.processingFee, processingFee)) {
+            _logUpdateFee(productNftId, "ProcessingFee", feeInfo.processingFee, processingFee);
+            feeInfo.processingFee = processingFee;
             feesChanged = true;
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateProduct(productNftId, productInfo, KEEP_STATE());
+            instance.getInstanceStore().updateFee(productNftId, feeInfo);
             emit LogComponentServiceProductFeesUpdated(productNftId);
         }
     }
 
-    function increaseProductFees(
-        InstanceStore instanceStore,
-        NftId productNftId, 
-        Amount feeAmount
-    ) 
-        external 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(productNftId, PRODUCT());
-        _changeTargetBalance(INCREASE, instanceStore, productNftId, AmountLib.zero(), feeAmount);
-    }
-
-
-    function decreaseProductFees(InstanceStore instanceStore, NftId productNftId, Amount feeAmount)
-        external 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(productNftId, PRODUCT());
-        _changeTargetBalance(DECREASE, instanceStore, productNftId, AmountLib.zero(), feeAmount);
-    }
-
     //-------- distribution -------------------------------------------------//
 
     /// @dev registers the sending component as a distribution component
@@ -333,10 +313,6 @@ contract ComponentService is
         // set distribution in product info
         productInfo.distributionNftId = distributionNftId;
         instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
-
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(
-            IInstanceLinkedComponent(distributioAddress));
     }
 
 
@@ -348,93 +324,30 @@ contract ComponentService is
         virtual
     {
         (NftId distributionNftId, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
-        (NftId productNftId, IComponents.ProductInfo memory productInfo) = _getLinkedProductInfo(
+        (NftId productNftId, IComponents.FeeInfo memory feeInfo) = _getLinkedFeeInfo(
             instance.getInstanceReader(), distributionNftId);
         bool feesChanged = false;
 
         // update distributino fee if required
-        if(!FeeLib.eq(productInfo.distributionFee, distributionFee)) {
-            _logUpdateFee(productNftId, "DistributionFee", productInfo.distributionFee, distributionFee);
-            productInfo.distributionFee = distributionFee;
+        if(!FeeLib.eq(feeInfo.distributionFee, distributionFee)) {
+            _logUpdateFee(productNftId, "DistributionFee", feeInfo.distributionFee, distributionFee);
+            feeInfo.distributionFee = distributionFee;
             feesChanged = true;
         }
 
         // update min distribution owner fee if required
-        if(!FeeLib.eq(productInfo.minDistributionOwnerFee, minDistributionOwnerFee)) {
-            _logUpdateFee(productNftId, "MinDistributionOwnerFee", productInfo.minDistributionOwnerFee, minDistributionOwnerFee);
-            productInfo.minDistributionOwnerFee = minDistributionOwnerFee;
+        if(!FeeLib.eq(feeInfo.minDistributionOwnerFee, minDistributionOwnerFee)) {
+            _logUpdateFee(productNftId, "MinDistributionOwnerFee", feeInfo.minDistributionOwnerFee, minDistributionOwnerFee);
+            feeInfo.minDistributionOwnerFee = minDistributionOwnerFee;
             feesChanged = true;
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateProduct(productNftId, productInfo, KEEP_STATE());
+            instance.getInstanceStore().updateFee(productNftId, feeInfo);
             emit LogComponentServiceDistributionFeesUpdated(distributionNftId);
         }
     }
 
-    function increaseDistributionBalance(
-        InstanceStore instanceStore, 
-        NftId distributionNftId, 
-        Amount amount,
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(distributionNftId, DISTRIBUTION());
-        _changeTargetBalance(INCREASE, instanceStore, distributionNftId, amount, feeAmount);
-    }
-
-
-    function decreaseDistributionBalance(
-        InstanceStore instanceStore, 
-        NftId distributionNftId, 
-        Amount amount,
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(distributionNftId, DISTRIBUTION());
-        _changeTargetBalance(DECREASE, instanceStore, distributionNftId, amount, feeAmount);
-    }
-
-    //-------- distributor -------------------------------------------------------//
-
-    function increaseDistributorBalance(
-        InstanceStore instanceStore, 
-        NftId distributorNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(distributorNftId, DISTRIBUTOR());
-        _changeTargetBalance(INCREASE, instanceStore, distributorNftId, amount, feeAmount);
-    }
-
-    function decreaseDistributorBalance(
-        InstanceStore instanceStore, 
-        NftId distributorNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(distributorNftId, DISTRIBUTOR());
-        _changeTargetBalance(DECREASE, instanceStore, distributorNftId, amount, feeAmount);
-    }
-
     //-------- oracle -------------------------------------------------------//
 
     function _registerOracle(address oracleAddress)
@@ -465,10 +378,6 @@ contract ComponentService is
         productInfo.oracleNftId[productInfo.numberOfOracles] = oracleNftId;
         productInfo.numberOfOracles++;
         instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
-
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(
-            IInstanceLinkedComponent(oracleAddress));
     }
 
     //-------- pool ---------------------------------------------------------//
@@ -503,9 +412,6 @@ contract ComponentService is
         // update pool in product info
         productInfo.poolNftId = poolNftId;
         instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
-
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(pool);
     }
 
 
@@ -519,123 +425,37 @@ contract ComponentService is
     {
         (NftId poolNftId, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
-        (NftId productNftId, IComponents.ProductInfo memory productInfo) = _getLinkedProductInfo(
+        (NftId productNftId, IComponents.FeeInfo memory feeInfo) = _getLinkedFeeInfo(
             instance.getInstanceReader(), poolNftId);
         bool feesChanged = false;
 
         // update pool fee if required
-        if(!FeeLib.eq(productInfo.poolFee, poolFee)) {
-            _logUpdateFee(productNftId, "PoolFee", productInfo.poolFee, poolFee);
-            productInfo.poolFee = poolFee;
+        if(!FeeLib.eq(feeInfo.poolFee, poolFee)) {
+            _logUpdateFee(productNftId, "PoolFee", feeInfo.poolFee, poolFee);
+            feeInfo.poolFee = poolFee;
             feesChanged = true;
         }
 
         // update staking fee if required
-        if(!FeeLib.eq(productInfo.stakingFee, stakingFee)) {
-            _logUpdateFee(productNftId, "StakingFee", productInfo.stakingFee, stakingFee);
-            productInfo.stakingFee = stakingFee;
+        if(!FeeLib.eq(feeInfo.stakingFee, stakingFee)) {
+            _logUpdateFee(productNftId, "StakingFee", feeInfo.stakingFee, stakingFee);
+            feeInfo.stakingFee = stakingFee;
             feesChanged = true;
         }
 
         // update performance fee if required
-        if(!FeeLib.eq(productInfo.performanceFee, performanceFee)) {
-            _logUpdateFee(productNftId, "PerformanceFee", productInfo.performanceFee, performanceFee);
-            productInfo.performanceFee = performanceFee;
+        if(!FeeLib.eq(feeInfo.performanceFee, performanceFee)) {
+            _logUpdateFee(productNftId, "PerformanceFee", feeInfo.performanceFee, performanceFee);
+            feeInfo.performanceFee = performanceFee;
             feesChanged = true;
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateProduct(productNftId, productInfo, KEEP_STATE());
+            instance.getInstanceStore().updateFee(productNftId, feeInfo);
             emit LogComponentServicePoolFeesUpdated(poolNftId);
         }
     }
 
-    function increasePoolBalance(
-        InstanceStore instanceStore, 
-        NftId poolNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        public 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(poolNftId, POOL());
-        _changeTargetBalance(INCREASE, instanceStore, poolNftId, amount, feeAmount);
-    }
-
-    function decreasePoolBalance(
-        InstanceStore instanceStore, 
-        NftId poolNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        public 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(poolNftId, POOL());
-        _changeTargetBalance(DECREASE, instanceStore, poolNftId, amount, feeAmount);
-    }
-
-    //-------- bundle -------------------------------------------------------//
-
-    function increaseBundleBalance(
-        InstanceStore instanceStore, 
-        NftId bundleNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(bundleNftId, BUNDLE());
-        _changeTargetBalance(INCREASE, instanceStore, bundleNftId, amount, feeAmount);
-    }
-
-    function decreaseBundleBalance(
-        InstanceStore instanceStore, 
-        NftId bundleNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _checkNftType(bundleNftId, BUNDLE());
-        _changeTargetBalance(DECREASE, instanceStore, bundleNftId, amount, feeAmount);
-    }
-
-
-    //-------- internal functions ------------------------------------------//
-
-    function _changeTargetBalance(
-        bool increase,
-        InstanceStore instanceStore, 
-        NftId targetNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        internal
-        virtual
-    {
-        Amount totalAmount = amount + feeAmount;
-
-        if(increase) {
-            if(totalAmount.gtz()) { instanceStore.increaseBalance(targetNftId, totalAmount); }
-            if(feeAmount.gtz()) { instanceStore.increaseFees(targetNftId, feeAmount); }
-        } else {
-            if(totalAmount.gtz()) { instanceStore.decreaseBalance(targetNftId, totalAmount); }
-            if(feeAmount.gtz()) { instanceStore.decreaseFees(targetNftId, feeAmount); }
-        }
-    }
-
     /// @dev Registers the component represented by the provided address.
     function _register(
         address componentAddress, // address of component to register
@@ -690,9 +510,6 @@ contract ComponentService is
             address(token), 
             address(instanceAdmin.authority()));
         
-        // set token handler allowance to max
-        // componentInfo.tokenHandler.approve(token, AmountLib.max());
-
         // register component with instance
         instanceStore.createComponent(
             componentNftId, 
@@ -701,6 +518,9 @@ contract ComponentService is
         // link component contract to nft id
         component.linkToRegisteredNftId();
 
+        // authorize
+        instanceAdmin.initializeComponentAuthorization(component);
+
         emit LogComponentServiceRegistered(instanceNftId, componentNftId, requiredType, address(component), address(token), initialOwner);
     }
 
@@ -720,7 +540,7 @@ contract ComponentService is
     }
 
 
-    function _getLinkedProductInfo(
+    function _getLinkedFeeInfo(
         InstanceReader instanceReader, 
         NftId componentNftId
     )
@@ -728,11 +548,11 @@ contract ComponentService is
         view 
         returns(
             NftId productNftId, 
-            IComponents.ProductInfo memory info
+            IComponents.FeeInfo memory info
         )
     {
-        productNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
-        info = instanceReader.getProductInfo(productNftId);
+        productNftId = getRegistry().getParentNftId(componentNftId);
+        info = instanceReader.getFeeInfo(productNftId);
     }
 
 
@@ -780,9 +600,12 @@ contract ComponentService is
             revert ErrorComponentServiceAlreadyRegistered(componentAddress);
         }
 
-        // check release matches
+        // component release matches servie release
         address parentAddress = registry.getObjectAddress(parentNftId);
-        if (component.getRelease() != IRegisterable(parentAddress).getRelease()) {
+        if (component.getRelease() != getRelease()) {
+            revert ErrorComponentServiceReleaseMismatch(componentAddress, component.getRelease(), getRelease());
+        // component release matches parent release
+        } else if (component.getRelease() != IRegisterable(parentAddress).getRelease()){
             revert ErrorComponentServiceReleaseMismatch(componentAddress, component.getRelease(), IRegisterable(parentAddress).getRelease());
         }
 

package/contracts/shared/ComponentServiceManager.sol

@@ -17,7 +17,7 @@ contract ComponentServiceManager is ProxyManager {
     )
     {
         ComponentService svc = new ComponentService();
-        bytes memory data = abi.encode(registry, authority);
+        bytes memory data = abi.encode(authority, registry);
         IVersionable versionable = initialize(
             registry,
             address(svc), 

package/contracts/shared/ComponentVerifyingService.sol

@@ -116,7 +116,7 @@ abstract contract ComponentVerifyingService is
     /// @dev returns the product nft id from the registry.
     /// assumes the component nft id is valid and represents a product linked component.
     function _getProductNftId(NftId componentNftId) internal view returns (NftId productNftId) {
-        productNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        productNftId = getRegistry().getParentNftId(componentNftId);
     }
 
 

package/contracts/shared/ContractLib.sol

@@ -2,12 +2,14 @@
 pragma solidity ^0.8.20;
 
 import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
 
 // import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IPolicyHolder} from "../shared/IPolicyHolder.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType, PRODUCT, DISTRIBUTION, ORACLE, POOL, STAKING} from "../type/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
 
 interface ITargetHelper {
     function isTargetLocked(address target) external view returns (bool);
@@ -17,6 +19,10 @@ interface IInstanceAdminHelper {
     function getInstanceAdmin() external view returns (ITargetHelper);
 }
 
+interface ITokenRegistryHelper {
+    function isActive(uint256 chainId, address token, VersionPart release) external view returns (bool);
+}
+
 library ContractLib {
 
     error ErrorContractLibNotRegistered(address target);
@@ -25,7 +31,6 @@ library ContractLib {
     error ErrorContractLibComponentTypeMismatch(NftId componentNftId, ObjectType expectedType, ObjectType actualType);
     error ErrorContractLibComponentInactive(NftId componentNftId);
 
-
     function getAndVerifyComponent(
         IRegistry registry, 
         address target,
@@ -130,17 +135,41 @@ library ContractLib {
         view
         returns (address instance)
     {
-        NftId productNftId = registry.getObjectInfo(componentNftId).parentNftId;
-        NftId instanceNftId = registry.getObjectInfo(productNftId).parentNftId;
+        NftId productNftId = registry.getParentNftId(componentNftId);
+        NftId instanceNftId = registry.getParentNftId(productNftId);
         return registry.getObjectInfo(instanceNftId).objectAddress;
     }
 
 
+    function isActiveToken(
+        address tokenRegistryAddress,
+        address token,
+        uint256 chainId, 
+        VersionPart release
+    )
+        external 
+        view 
+        returns (bool)
+    {
+        return ITokenRegistryHelper(
+            tokenRegistryAddress).isActive(
+                chainId, token, release);
+    }
+
     function isPolicyHolder(address target) external view returns (bool) {
         return ERC165Checker.supportsInterface(target, type(IPolicyHolder).interfaceId);
     }
 
 
+    function isAuthority(address authority) public view returns (bool) {
+        if (!isContract(authority)) {
+            return false;
+        }
+
+        return supportsInterface(authority, type(IAccessManager).interfaceId);
+    }
+
+
     function isRegistry(address registry) public view returns (bool) {
         if (!isContract(registry)) {
             return false;