@etherisc/gif-next 0.0.2-d0b1ffb-653 → 0.0.2-d0faf15-906

package/contracts/shared/ComponentVerifyingService.sol

@@ -5,7 +5,7 @@ import {IInstance} from "../instance/IInstance.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, DISTRIBUTION, ORACLE, POOL, PRODUCT} from "../type/ObjectType.sol";
+import {ObjectType, COMPONENT, DISTRIBUTION, ORACLE, POOL, PRODUCT, STAKING} from "../type/ObjectType.sol";
 import {Service} from "../shared/Service.sol";
 
 
@@ -27,12 +27,12 @@ abstract contract ComponentVerifyingService is
         view
         returns(
             NftId componentNftId,
-            IRegistry.ObjectInfo memory componentInfo, 
+            IRegistry.ObjectInfo memory objectInfo, 
             IInstance instance
         )
     {
         componentNftId = getRegistry().getNftIdForAddress(msg.sender);
-        (componentInfo, instance) = _getAndVerifyComponentInfo(
+        (objectInfo, instance) = _getAndVerifyComponentInfo(
             componentNftId, 
             expectedType,
             true); // only active
@@ -82,7 +82,15 @@ abstract contract ComponentVerifyingService is
             }
         }
 
-        instance = _getInstanceForComponent(registry, info);
+        if (info.objectType == STAKING()) {
+            return (info, instance);
+        }
+        
+        if (info.objectType == PRODUCT()) {
+            instance = _getInstance(registry, info.parentNftId);
+        } else {
+            instance = _getInstanceForComponent(registry, info.parentNftId);
+        }
 
         // ensure component is not locked
         if (onlyActive) {
@@ -93,21 +101,15 @@ abstract contract ComponentVerifyingService is
     }
 
 
-    function _getInstanceForComponent(IRegistry registry, IRegistry.ObjectInfo memory componentInfo)
+    function _getInstanceForComponent(IRegistry registry, NftId productNftId)
         internal
         view
         returns (IInstance instance)
     {
-        // parent of product is instance
-        if (componentInfo.objectType == PRODUCT()) {
-            instance = _getInstance(registry, componentInfo.parentNftId);
-        // parent of other types is product
-        } else {
-            instance = _getInstance(
+        return _getInstance(
                 registry,
                 registry.getObjectInfo(
-                    componentInfo.parentNftId).parentNftId);
-        }
+                    productNftId).parentNftId);
     }
 
 

package/contracts/shared/ContractLib.sol

@@ -2,29 +2,187 @@
 pragma solidity ^0.8.20;
 
 import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
 
-import {IPolicyHolder} from "./IPolicyHolder.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);
+}
+
+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);
+    error ErrorContractLibNotComponent(NftId componentNftId, ObjectType objectType);
+    error ErrorContractLibNotStaking(NftId componentNftId, ObjectType objectType);
+    error ErrorContractLibComponentTypeMismatch(NftId componentNftId, ObjectType expectedType, ObjectType actualType);
+    error ErrorContractLibComponentInactive(NftId componentNftId);
+
+    function getAndVerifyComponent(
+        IRegistry registry, 
+        address target,
+        ObjectType expectedType,
+        bool onlyActive
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info, 
+            address instance
+        )
+    {
+        // check target is component
+        info = _getObjectInfo(registry, target);
+        if(info.objectType != expectedType) {
+            revert ErrorContractLibComponentTypeMismatch(
+                info.nftId,
+                expectedType,
+                info.objectType);
+        }
+
+        // get instance and check component is active
+        instance = _getInstance(registry, info);
+        _checkComponentActive(instance, target, info.nftId, onlyActive);
+    }
+
+
+    function getInfoAndInstance(
+        IRegistry registry,
+        NftId componentNftId,
+        bool onlyActive
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info, 
+            address instance
+        )
+    {
+        info = registry.getObjectInfo(componentNftId);
+        instance = _getInstance(registry, info);
+        _checkComponentActive(instance, info.objectAddress, info.nftId, onlyActive);
+    }
+
+
+    function getAndVerifyStaking(
+        IRegistry registry, 
+        address target
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info
+        )
+    {
+        // check target is component
+        info = _getObjectInfo(registry, target);
+        if(info.objectType != STAKING()) {
+            revert ErrorContractLibNotStaking(
+                info.nftId,
+                info.objectType);
+        }
+    }
+
+
+    function getAndVerifyAnyComponent(
+        IRegistry registry, 
+        address target,
+        bool onlyActive
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info, 
+            address instance
+        )
+    {
+        // check target is component
+        info = _getObjectInfo(registry, target);
+        if(!(info.objectType == PRODUCT()
+            || info.objectType == POOL()
+            || info.objectType == DISTRIBUTION()
+            || info.objectType == ORACLE())
+        ) {
+            revert ErrorContractLibNotComponent(
+                info.nftId,
+                info.objectType);
+        }
+
+        // get instance and check component is active
+        instance = _getInstance(registry, info);
+        _checkComponentActive(instance, target, info.nftId, onlyActive);
+    }
+
+
+    function getInstanceForComponent(
+        IRegistry registry, 
+        NftId componentNftId
+    )
+        public
+        view
+        returns (address instance)
+    {
+        NftId productNftId = registry.getObjectInfo(componentNftId).parentNftId;
+        NftId instanceNftId = registry.getObjectInfo(productNftId).parentNftId;
+        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 isAccessManaged(address target) external view returns (bool) {
-        if (!isContract(target)) {
+
+    function isAuthority(address authority) public view returns (bool) {
+        if (!isContract(authority)) {
             return false;
         }
 
-        (bool success, ) = target.staticcall(
-            abi.encodeWithSelector(
-                IAccessManaged.authority.selector));
+        return supportsInterface(authority, type(IAccessManager).interfaceId);
+    }
+
+
+    function isRegistry(address registry) public view returns (bool) {
+        if (!isContract(registry)) {
+            return false;
+        }
 
-        return success;
+        return supportsInterface(registry, type(IRegistry).interfaceId);
     }
 
+
     function isContract(address target) public view returns (bool) {
+        if (target == address(0)) {
+            return false;
+        }
+
         uint256 size;
         assembly {
             size := extcodesize(target)
@@ -32,7 +190,63 @@ library ContractLib {
         return size > 0;
     }
 
-    function supportsInterface(address target, bytes4 interfaceId)  external view returns (bool) {
+    function supportsInterface(address target, bytes4 interfaceId)  public view returns (bool) {
         return ERC165Checker.supportsInterface(target, interfaceId);
     }
+
+
+    function _checkComponentActive(
+        address instance, 
+        address target, 
+        NftId componentNftId, 
+        bool onlyActive
+    )
+        internal
+        view
+    {
+        if (onlyActive) {
+            if (IInstanceAdminHelper(
+                instance).getInstanceAdmin().isTargetLocked(
+                    target)
+            ) {
+                revert ErrorContractLibComponentInactive(componentNftId);
+            }
+        }
+    }
+
+
+    function _getInstance(
+        IRegistry registry,
+        IRegistry.ObjectInfo memory info
+    )
+        internal
+        view
+        returns (address instance)
+    {
+        if (info.objectType == PRODUCT()) {
+            return registry.getObjectAddress(
+                info.parentNftId);
+        } 
+        
+        return registry.getObjectAddress(
+                registry.getObjectInfo(
+                    info.parentNftId).parentNftId);
+    }
+
+
+    function _getObjectInfo(
+        IRegistry registry, 
+        address target
+    )
+        internal
+        view
+        returns (IRegistry.ObjectInfo memory info)
+    {
+        NftId componentNftId = registry.getNftIdForAddress(target);
+        if (componentNftId.eqz()) {
+            revert ErrorContractLibNotRegistered(target);
+        }
+
+        info = registry.getObjectInfo(componentNftId);
+    }
 }

package/contracts/shared/IComponent.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 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";
@@ -13,37 +12,25 @@ import {TokenHandler} from "../shared/TokenHandler.sol";
 /// @dev component base class
 /// component examples are staking, product, distribution, pool and oracle
 interface IComponent is 
-    IAccessManaged,
     IRegisterable,
     ITransferInterceptor
 {
+
+    error ErrorComponentTokenInvalid(address token);
+
     error ErrorComponentProductNftIdZero();
     error ErrorComponentProductNftIdNonzero();
     error ErrorComponentNameLengthZero();
 
     error ErrorComponentNotChainNft(address caller);
 
-    error ErrorComponentTokenAddressNonzero();
-    error ErrorComponentTokenAddressZero();
     error ErrorComponentWalletAddressZero();
     error ErrorComponentWalletAddressIsSameAsCurrent();
     error ErrorComponentWalletNotComponent();
 
     event LogComponentWalletAddressChanged(address oldWallet, address newWallet);
     event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
-    event LogComponentTokenHandlerApproved(address token, Amount limit, bool isMaxAmount);
-
-    /// @dev approves token hanlder to spend up to the specified amount of tokens
-    /// reverts if component wallet is not component itself
-    /// only component owner (nft holder) is authorizes to call this function
-    function approveTokenHandler(Amount spendingLimitAmount) external;
-
-    /// @dev sets the wallet address for the component.
-    /// if the current wallet has tokens, these will be transferred.
-    /// if the new wallet address is externally owned, an approval from the 
-    /// owner of the external wallet to the tokenhandler of the component that 
-    /// covers the current component balance must exist
-    function setWallet(address walletAddress) external;
+    event LogComponentTokenHandlerApproved(address tokenHandler, address token, Amount limit, bool isMaxAmount);
 
     /// @dev returns the name of this component
     /// to successfully register the component with an instance the name MUST be unique in the linked instance

package/contracts/shared/IComponentService.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 import {Amount} from "../type/Amount.sol";
 import {Fee} from "../type/Fee.sol";
-import {InstanceStore} from "../instance/InstanceStore.sol";
 import {IService} from "../shared/IService.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType} from "../type/ObjectType.sol";
@@ -27,6 +27,10 @@ interface IComponentService is
     error ErrorComponentServiceParentNotInstance(NftId nftId, ObjectType objectType);
     error ErrorComponentServiceParentNotProduct(NftId nftId, ObjectType objectType);
 
+    error ErrorComponentServiceNotRegistered(address instanceAddress);
+    error ErrorComponentServiceNotInstance(address instanceAddress, ObjectType objectType);
+    error ErrorComponentServiceInstanceVersionMismatch(address instanceAddress, VersionPart instanceVersion);
+    
     error ErrorProductServiceNoDistributionExpected(NftId productNftId);
     error ErrorProductServiceDistributionAlreadyRegistered(NftId productNftId, NftId distributionNftId);
     error ErrorProductServiceNoOraclesExpected(NftId productNftId);
@@ -43,6 +47,7 @@ interface IComponentService is
 
     event LogComponentServiceRegistered(NftId instanceNftId, NftId componentNftId, ObjectType componentType, address component, address token, address initialOwner); 
     event LogComponentServiceWalletAddressChanged(NftId componentNftId, address currentWallet, address newWallet);
+    event LogComponentServiceWalletTokensTransferred(NftId componentNftId, address currentWallet, address newWallet, uint256 currentBalance);
     event LogComponentServiceComponentFeesWithdrawn(NftId componentNftId, address recipient, address token, Amount withdrawnAmount);
     event LogComponentServiceProductFeesUpdated(NftId productNftId);
     event LogComponentServiceDistributionFeesUpdated(NftId distributionNftId);
@@ -55,17 +60,25 @@ interface IComponentService is
         UFixed newFractionalFee, 
         uint256 newFixedFee
     );
-
+    
     //-------- component ----------------------------------------------------//
 
-    /// @dev sets the components associated wallet address
+    /// @dev Approves the callers token handler to spend up to the specified amount of tokens.
+    /// Reverts if the component's token handler wallet is not the token handler itself.
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external;
+
+    /// @dev Approves the staking token handler.
+    /// Reverts if the staking token handler wallet is not the token handler itself.
+    function approveStakingTokenHandler(IERC20Metadata token, Amount amount) external;
+
+    /// @dev Sets the components associated wallet address
     function setWallet(address newWallet) external;
 
-    /// @dev locks the component associated with the caller
-    function lock() external;
+    /// @dev Locks/Unlocks the given component - call from instanceService
+    function setLockedFromInstance(address componentAddress, bool locked) external;
 
-    /// @dev unlocks the component associated with the caller
-    function unlock() external;
+    /// @dev Locks/Unlocks the given component - call from component
+    function setLockedFromComponent(address componentAddress, bool locked) external;
 
     /// @dev Withdraw fees from the distribution component. Only component owner is allowed to withdraw fees.
     /// @param withdrawAmount the amount to withdraw
@@ -85,9 +98,6 @@ interface IComponentService is
         Fee memory processingFee // product fee on payout amounts        
     ) external;
 
-    function increaseProductFees(InstanceStore instanceStore, NftId productNftId, Amount feeAmount) external;
-    function decreaseProductFees(InstanceStore instanceStore, NftId productNftId, Amount feeAmount) external;
-
     //-------- distribution -------------------------------------------------//
 
     function setDistributionFees(
@@ -95,13 +105,6 @@ interface IComponentService is
         Fee memory minDistributionOwnerFee // min fee required by distribution owner (not including commissions for distributors)
     ) external;
 
-    function increaseDistributionBalance(InstanceStore instanceStore, NftId distributionNftId, Amount amount, Amount feeAmount) external;
-    function decreaseDistributionBalance(InstanceStore instanceStore, NftId distributionNftId, Amount amount, Amount feeAmount) external;
-
-    //-------- distributor --------------------------------------------------//
-    function increaseDistributorBalance(InstanceStore instanceStore, NftId distributorNftId, Amount amount, Amount feeAmount) external;
-    function decreaseDistributorBalance(InstanceStore instanceStore, NftId distributorNftId, Amount amount, Amount feeAmount) external;
-
     //-------- pool ---------------------------------------------------------//
 
     function setPoolFees(
@@ -110,11 +113,4 @@ interface IComponentService is
         Fee memory performanceFee // pool fee on profits from capital investors
     ) external;
 
-    function increasePoolBalance(InstanceStore instanceStore, NftId poolNftId, Amount amount, Amount feeAmount) external;
-    function decreasePoolBalance(InstanceStore instanceStore, NftId poolNftId, Amount amount, Amount feeAmount) external;
-
-    //-------- bundle -------------------------------------------------------//
-    function increaseBundleBalance(InstanceStore instanceStore, NftId bundleNftId, Amount amount, Amount feeAmount) external;
-    function decreaseBundleBalance(InstanceStore instanceStore, NftId bundleNftId, Amount amount, Amount feeAmount) external;
-
 }

package/contracts/shared/IInstanceLinkedComponent.sol

@@ -1,9 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 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 "../shared/IComponent.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
@@ -19,14 +16,6 @@ interface IInstanceLinkedComponent is
     error ErrorInstanceLinkedComponentTypeMismatch(ObjectType requiredType, ObjectType objectType);
     error ErrorInstanceLinkedComponentNotProduct(NftId nftId, ObjectType objectType);
 
-    /// @dev locks component to disable functions that may change state related to this component, the only exception is function "unlock"
-    /// only component owner (nft holder) is authorizes to call this function
-    function lock() external;
-
-    /// @dev unlocks component to (re-)enable functions that may change state related to this component
-    /// only component owner (nft holder) is authorizes to call this function
-    function unlock() external;
-
     /// @dev Withdraw fees from the distribution component. Only component owner is allowed to withdraw fees.
     /// @param amount the amount to withdraw
     /// @return withdrawnAmount the amount that was actually withdrawn

package/contracts/shared/IRegisterable.sol

@@ -1,7 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
 import {INftOwnable} from "./INftOwnable.sol";
+import {IRelease} from "../registry/IRelease.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {VersionPart} from "../type/Version.sol";
 
@@ -9,11 +12,19 @@ import {VersionPart} from "../type/Version.sol";
 /// @dev Marks contracts that are intended to be registered in the registry.
 /// 
 interface IRegisterable is
-    INftOwnable
+    IAccessManaged,
+    INftOwnable,
+    IRelease
 {
-    /// @dev retuns the GIF release version for this contract.
-    /// This 
-    function getRelease() external pure returns (VersionPart release);
+    // __Registerable_init
+    error ErrorAuthorityInvalid(address authority);
+
+    // onlyActive()
+    error ErrorRegisterableNotActive();
+
+    /// @dev Returns true iff this contract managed by its authority is active.
+    /// Queries the IAccessManaged.authority().
+    function isActive() external view returns (bool active);
 
     /// @dev retuns the object info relevant for registering for this contract 
     /// IMPORTANT information returned by this function may only be used

package/contracts/shared/IService.sol

@@ -9,17 +9,15 @@ import {ObjectType} from "../type/ObjectType.sol";
 import {RoleId} from "../type/RoleId.sol";
 
 interface IService is 
+    IAccessManaged,
     IRegisterable,
-    IVersionable,
-    IAccessManaged
+    IVersionable
 {
-    error ErrorServiceNotImplemented();
-
     /// @dev returns the domain for this service.
     /// In any GIF release only one service for any given domain may be deployed.
     function getDomain() external pure returns(ObjectType serviceDomain);
 
     /// @dev returns the GIF release specific role id.
     /// These role ids are used to authorize service to service communication.
-    function getRoleId() external pure returns(RoleId serviceRoleId);
+    function getRoleId() external view returns(RoleId serviceRoleId);
 }

package/contracts/shared/InstanceLinkedComponent.sol

@@ -40,20 +40,12 @@ abstract contract InstanceLinkedComponent is
         IComponentService _componentService;
     }
 
-    function lock() external onlyOwner {
-        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(true);
-    }
-    
-    function unlock() external onlyOwner {
-        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(false);
-    }
-
     /// @inheritdoc IInstanceLinkedComponent
     function withdrawFees(Amount amount)
         external
         virtual
-        onlyOwner()
         restricted()
+        onlyOwner()
         returns (Amount withdrawnAmount)
     {
         return _withdrawFees(amount);
@@ -181,7 +173,7 @@ abstract contract InstanceLinkedComponent is
             info = _getInstanceReader().getComponentInfo(getNftId());
 
             // check if also registered with instance
-            if (info.wallet != address(0)) {
+            if (address(info.tokenHandler) != address(0)) {
                 return info;
             }
         }
@@ -202,12 +194,4 @@ abstract contract InstanceLinkedComponent is
     {
         return _getInstanceLinkedComponentStorage()._componentService.withdrawFees(amount);
     }
-
-
-    /// @dev returns the service address for the specified domain
-    /// gets address via lookup from registry using the major version form the linked instance
-    function _getServiceAddress(ObjectType domain) internal view returns (address service) {
-        VersionPart release = _getInstanceLinkedComponentStorage()._instance.getRelease();
-        return getRegistry().getServiceAddress(domain, release);
-    }
 }

package/contracts/shared/NftOwnable.sol

@@ -36,16 +36,20 @@ contract NftOwnable is
     }
 
     modifier onlyNftOfType(NftId nftId, ObjectType expectedObjectType) {
+        _checkNftType(nftId, expectedObjectType);
+        _;
+    }
+
+    function _checkNftType(NftId nftId, ObjectType expectedObjectType) internal view {
         if(!getRegistry().isObjectType(nftId, expectedObjectType)) {
             revert ErrorNftOwnableInvalidType(nftId, expectedObjectType);
         }
-        _;
     }
 
 
-    /// @dev initialization for upgradable contracts
-    // used in _initializeRegisterable
-    function _initializeNftOwnable(
+    /// @dev Initialization for upgradable contracts.
+    // used in __Registerable_init, ProxyManager._preDeployChecksAndSetup
+    function __NftOwnable_init(
         address registry,
         address initialOwner
     )
@@ -53,7 +57,7 @@ contract NftOwnable is
         virtual
         onlyInitializing()
     {
-        _initializeRegistryLinked(registry);
+        __RegistryLinked_init(registry);
         _initializeERC165();
 
         if(initialOwner == address(0)) {

package/contracts/shared/PolicyHolder.sol

@@ -29,7 +29,7 @@ contract PolicyHolder is
         virtual
         onlyInitializing()
     {
-        _initializeRegistryLinked(registryAddress);
+        __RegistryLinked_init(registryAddress);
         _initializeERC165();
         _registerInterface(type(IPolicyHolder).interfaceId);
     }