@etherisc/gif-next 3.0.0-c0923b6f-772-12c20a7-167 → 3.0.0-c458de2-735

package/contracts/shared/ContractLib.sol

@@ -5,114 +5,376 @@ import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165C
 import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
+import {IInstance} from "../instance/IInstance.sol";
+import {IOracleComponent} from "../oracle/IOracleComponent.sol";
 import {IPolicyHolder} from "../shared/IPolicyHolder.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IService} from "../shared/IService.sol";
 
 import {ChainId} from "../type/ChainId.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, INSTANCE, PRODUCT, DISTRIBUTION, ORACLE, POOL} from "../type/ObjectType.sol";
+import {ObjectType, INSTANCE, COMPONENT, PRODUCT, DISTRIBUTION, ORACLE, POOL, POLICY, BUNDLE} from "../type/ObjectType.sol";
+import {TokenRegistry} from "../registry/TokenRegistry.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);
-}
+library ContractLib {
 
-interface ITokenRegistryHelper {
-    function isActive(ChainId chainId, address token, VersionPart release) external view returns (bool);
-}
+    error ErrorContractLibCallerNotRegistered(address caller);
+    error ErrorContractLibCallerNotComponent(/*address caller, */NftId callerNftId, ObjectType callerType);
+    error ErrorContractLibParentNotInstance(/*address component, */NftId componentNftId, NftId parentNftId/*, ObjectType parentType*/);
+    error ErrorContractLibParentNotProduct(/*address component, */NftId componentNftId, NftId parentNftId/*, ObjectType parentType*/);
+    error ErrorContractLibComponentTypeMismatch(/*address component, */NftId componentNftId, ObjectType expectedType, ObjectType actualType);
+    error ErrorContractLibComponentReleaseMismatch(/*address component, */NftId componentNftId, VersionPart expectedRelease, VersionPart actualRelease);
+    error ErrorContractLibComponentInactive(/*address component, */NftId componentNftId);
 
-library ContractLib {
+    error ErrorContractLibObjectNotRegistered(NftId objectNftId);
+    error ErrorContractLibObjectTypeMismatch(NftId objectNftId, ObjectType expectedType, ObjectType actualType);
+    error ErrorContractLibObjectReleaseMismatch(NftId objectNftId, VersionPart expectedRelease, VersionPart actualRelease);
+    error ErrorContractLibObjectParentMismatch(NftId objectNftId, NftId expectedParentNftId, NftId actualParentNftId);
+
+    error ErrorContractLibParentsMismatch(NftId componentNftId, NftId componentParentNftId, NftId objectNftId, NftId objectParentNftId);
 
-    error ErrorContractLibCallerNotRegistered(address target);
-    error ErrorContractLibCallerNotComponent(NftId componentNftId, ObjectType objectType);
-    error ErrorContractLibParentNotInstance(NftId componentNftId, NftId parentNftId);
-    error ErrorContractLibParentNotProduct(NftId componentNftId, NftId parentNftId);
-    error ErrorContractLibComponentTypeMismatch(NftId componentNftId, ObjectType expectedType, ObjectType actualType);
-    error ErrorContractLibComponentInactive(NftId componentNftId);
+
+
+    // update registry address whenever it changes
+    address public constant REGISTRY_ADDRESS = address(0x345cA3e014Aaf5dcA488057592ee47305D9B3e10);
+
+    function getRegistry() internal pure returns (IRegistry) {
+        return IRegistry(REGISTRY_ADDRESS);
+    }
+
+    function getAndVerifyProduct(VersionPart expectedRelease)
+        external
+        view
+        returns (
+            NftId, // productNftId
+            IInstance // instance,
+        )
+    {
+        return getAndVerifyComponent(
+            msg.sender,
+            PRODUCT(),
+            expectedRelease,
+            true); // only active product
+    }
+
+    function getAndVerifyPool(VersionPart expectedRelease)
+        external
+        view
+        returns (
+            NftId, // poolNftId
+            IInstance // instance,
+        )
+    {
+        return getAndVerifyComponent(
+            msg.sender,
+            POOL(),
+            expectedRelease,
+            true); // only active pool
+    }
+
+    function getAndVerifyProductForPolicy(NftId policyNftId, VersionPart expectedRelease)
+        external
+        view
+        returns (
+            NftId, // productNftId
+            IInstance // instance,
+        )
+    {
+        return getAndVerifyComponentWithChild(
+            msg.sender, // product
+            true, // only active product
+            policyNftId, // child nft id
+            POLICY(), // child must be policy
+            expectedRelease);
+    }
+
+    function getAndVerifyPoolForBundle(NftId bundleNftId, VersionPart expectedRelease)
+        external
+        view
+        returns (
+            NftId, // poolNftId
+            IInstance // instance,
+        )
+    {
+        return getAndVerifyComponentWithChild({
+            component: msg.sender, // pool 
+            onlyActive: true, // only active pool
+            childNftId: bundleNftId, // child nft id
+            expectedChildType: BUNDLE(), // child must be bundle
+            expectedRelease: expectedRelease});
+    }
+
+    function getAndVerifyPoolForPolicy(NftId policyNftId, VersionPart expectedRelease)
+        external
+        view
+        returns (
+            NftId poolNftId,
+            IInstance instance
+        )
+    {
+        (poolNftId,, instance) = getAndVerifyComponentAndObject({
+            component: msg.sender,  // pool
+            expectedComponentType: POOL(),
+            onlyActive: true,
+            objectNftId: policyNftId,
+            expectedObjectType: POLICY(),
+            expectedRelease: expectedRelease
+        });    
+    }
+
+    function getAndVerifyComponentAndOracle(
+        NftId oracleNftId,
+        VersionPart expectedRelease
+    )
+        external
+        view
+        returns (
+            NftId requesterNftId,
+            IOracleComponent oracle,
+            IInstance instance
+        )
+    {
+        address oracleAddress;
+        (requesterNftId, oracleAddress, instance) = getAndVerifyComponentAndObject({
+            component: msg.sender,
+            expectedComponentType: COMPONENT(),
+            onlyActive: true, 
+            objectNftId: oracleNftId,
+            expectedObjectType: ORACLE(),
+            expectedRelease: expectedRelease
+        });
+
+        oracle = IOracleComponent(oracleAddress);
+    }
 
 
     function getInfoAndInstance(
-        IRegistry registry,
         NftId componentNftId,
+        VersionPart release,
         bool onlyActive
     )
-        external
+        public
         view
         returns (
             IRegistry.ObjectInfo memory info, 
-            address instance
+            IInstance instance
         )
     {
+        IRegistry registry = getRegistry();
         info = registry.getObjectInfo(componentNftId);
-        return _getAndVerifyComponentAndInstance(registry, info, info.objectType, onlyActive);
+        (, instance) = _getAndVerifyComponentAndInstance(info, info.objectType, release, onlyActive);
     }
 
 
-    function getAndVerifyAnyComponent(
-        IRegistry registry, 
+    function getAndVerifyComponent(
         address caller,
+        ObjectType expectedType,
+        VersionPart expectedRelease,
         bool onlyActive
     )
-        external
+        public
         view
         returns (
-            IRegistry.ObjectInfo memory callerInfo, 
-            address instance
+            NftId componentNftId, 
+            IInstance instance
         )
     {
-        // check caller is component
-        callerInfo = _getAndVerifyObjectInfo(registry, caller);
-        if(!(callerInfo.objectType == PRODUCT()
-            || callerInfo.objectType == POOL()
-            || callerInfo.objectType == DISTRIBUTION()
-            || callerInfo.objectType == ORACLE())
-        ) {
-            revert ErrorContractLibCallerNotComponent(
-                callerInfo.nftId,
-                callerInfo.objectType);
+        // check caller is registered
+        IRegistry.ObjectInfo memory info = _getAndVerifyObjectInfo(caller);
+        // check caller info
+        return _getAndVerifyComponentAndInstance(info, expectedType, expectedRelease, onlyActive);
+    }
+
+    function getAndVerifyComponentWithChild(
+        address component,
+        bool onlyActive, 
+        NftId childNftId, 
+        ObjectType expectedChildType, // assume valid component type
+        VersionPart expectedRelease
+    ) 
+        public
+        view
+        returns (
+            //IRegistry.ObjectInfo memory info,  // component info
+            NftId componentNftId,
+            IInstance instance)
+    {
+        IRegistry registry = getRegistry();
+        IRegistry.ObjectInfo memory info = registry.getObjectInfo(childNftId);
+
+        // check child registration
+        if(info.nftId.eqz()) {
+            revert ErrorContractLibObjectNotRegistered(childNftId);
         }
 
-        return _getAndVerifyComponentAndInstance(registry, callerInfo, callerInfo.objectType, onlyActive);
-    }
+        // check child type
+        if(info.objectType != expectedChildType) {
+            revert ErrorContractLibObjectTypeMismatch(
+                childNftId, 
+                expectedChildType, 
+                info.objectType);
+        }
 
+        // check child release
+        if(info.release != expectedRelease) {
+            revert ErrorContractLibObjectReleaseMismatch(
+                childNftId, 
+                expectedRelease, 
+                info.release);
+        }
 
-    function getAndVerifyComponent(
-        IRegistry registry, 
-        address caller,
-        ObjectType expectedType,
-        bool onlyActive
+        info = registry.getObjectInfo(info.parentNftId);
+        componentNftId = info.nftId;
+
+        // check parent is component
+        if(info.objectAddress != component) {
+            revert ErrorContractLibObjectParentMismatch(
+                childNftId,
+                registry.getNftIdForAddress(component),
+                info.nftId);
+        }
+
+        // get instance
+        instance = getAndVerifyInstance(info);// _getAndVerifyInstance(info);
+
+        // check component is active
+        _checkComponentActive(
+            instance, 
+            component, 
+            componentNftId, 
+            onlyActive);
+    }
+
+    /// @dev 
+    // component is contract of type COMPONENT
+    // objectNftId is either contract of type COMPONENT or object of type POLICY, BUNDLE, etc.
+    //             is either child of component or have same parent as component
+    function getAndVerifyComponentAndObject(
+        address component,
+        ObjectType expectedComponentType,
+        bool onlyActive, 
+        NftId objectNftId,
+        ObjectType expectedObjectType,
+        VersionPart expectedRelease
     )
-        external
+        public
         view
         returns (
-            IRegistry.ObjectInfo memory info, 
-            address instance
-        )
+            NftId componentNftId,
+            address objectAddress, // 0 for non contracts objects
+            IInstance instance)
     {
-        info = _getAndVerifyObjectInfo(registry, caller);
-        return _getAndVerifyComponentAndInstance(registry, info, expectedType, onlyActive);
+        IRegistry registry = getRegistry();
+
+        IRegistry.ObjectInfo memory componentInfo = registry.getObjectInfo(component);
+        componentNftId = componentInfo.nftId;
+
+        // check component registered 
+
+        // check component type
+        if(expectedComponentType != COMPONENT()) {
+            if(componentInfo.objectType != expectedComponentType) {
+                revert ErrorContractLibComponentTypeMismatch(
+                    //component,
+                    componentInfo.nftId,
+                    expectedComponentType,
+                    componentInfo.objectType);
+            }
+        } else if(
+            !(
+                componentInfo.objectType == PRODUCT() ||
+                componentInfo.objectType == POOL() ||
+                componentInfo.objectType == DISTRIBUTION() ||
+                componentInfo.objectType == ORACLE()
+            )
+        ) {
+            revert ErrorContractLibCallerNotComponent(
+                //component,
+                componentInfo.nftId,
+                componentInfo.objectType);
+        }
+
+        // check component release
+        if(componentInfo.release != expectedRelease) {
+            revert ErrorContractLibComponentReleaseMismatch(
+                //component, 
+                componentInfo.nftId, 
+                expectedRelease, 
+                componentInfo.release);
+        }
+
+        IRegistry.ObjectInfo memory objectInfo = registry.getObjectInfo(objectNftId);
+        objectAddress = objectInfo.objectAddress;
+
+        // check object type
+        if(objectInfo.objectType != expectedObjectType) {
+            revert ErrorContractLibObjectTypeMismatch(
+                objectNftId, 
+                expectedObjectType, 
+                objectInfo.objectType);
+        }
+
+        if(componentInfo.objectType == PRODUCT()) {
+            // check object parent is product
+            if(componentInfo.nftId != objectInfo.parentNftId) {
+                revert ErrorContractLibObjectParentMismatch(
+                    objectNftId,
+                    objectInfo.parentNftId,
+                    componentInfo.nftId);
+            }
+        } else {
+            // check component parent is product
+
+            // check object parent is same product
+            if(componentInfo.parentNftId != objectInfo.parentNftId) {
+                revert ErrorContractLibParentsMismatch(
+                    componentInfo.nftId,
+                    componentInfo.parentNftId,
+                    objectNftId, 
+                    objectInfo.parentNftId);
+            }
+        }
+
+        // get instance
+        instance = getAndVerifyInstance(componentInfo);
+
+        // check component is active
+        _checkComponentActive(
+            instance, 
+            component, 
+            componentNftId, 
+            onlyActive);
     }
 
 
     function getInstanceForComponent(
-        IRegistry registry, 
         NftId componentNftId
     )
         public
         view
         returns (address instance)
     {
+        IRegistry registry = getRegistry();
         NftId productNftId = registry.getParentNftId(componentNftId);
         NftId instanceNftId = registry.getParentNftId(productNftId);
         return registry.getObjectInfo(instanceNftId).objectAddress;
     }
 
+    // TODO check array of nfts and array of types
+    //      need to call: checkNftType({nftId: {nftId1, nftId2, nftId3}, expectedObjectType: {.., .., ..}})
+    /*function checkNftType(NftId nftId, ObjectType expectedObjectType) external view {
+        VersionPart expectedRelease = getRelease();
+        if(expectedObjectType.eqz() || !_getRegistry().isObjectType(nftId, expectedObjectType, expectedRelease)) {
+            revert ErrorNftOwnableInvalidType(nftId, expectedObjectType, expectedRelease);
+        }
+    }*/
 
+    // TODO hardcoded token registry address?
     function isActiveToken(
         address tokenRegistryAddress,
         ChainId chainId, 
@@ -123,7 +385,7 @@ library ContractLib {
         view 
         returns (bool)
     {
-        return ITokenRegistryHelper(
+        return TokenRegistry(
             tokenRegistryAddress).isActive(
                 chainId, token, release);
     }
@@ -160,16 +422,6 @@ library ContractLib {
     }
 
 
-    function isRegistered(address registry, address caller, ObjectType expectedType) public view returns (bool) {
-        NftId nftId = IRegistry(registry).getNftIdForAddress(caller);
-        if (nftId.eqz()) {
-            return false;
-        }
-
-        return IRegistry(registry).getObjectInfo(nftId).objectType == expectedType;
-    }
-
-
     function isService(address service) public view returns (bool) {
         if (!isContract(service)) {
             return false;
@@ -179,12 +431,8 @@ library ContractLib {
     }
 
 
-    function isRegistry(address registry) public view returns (bool) {
-        if (!isContract(registry)) {
-            return false;
-        }
-
-        return supportsInterface(registry, type(IRegistry).interfaceId);
+    function isRegistry(address registry) public pure returns (bool) {
+        return registry == REGISTRY_ADDRESS;
     }
 
 
@@ -206,39 +454,59 @@ library ContractLib {
 
 
     function _getAndVerifyComponentAndInstance(
-        IRegistry registry, 
         IRegistry.ObjectInfo memory info,
         ObjectType expectedType,
+        VersionPart expectedRelease,
         bool onlyActive
     )
         internal
         view
         returns (
-            IRegistry.ObjectInfo memory, 
-            address instance
+            NftId componentNftId,
+            IInstance instance
         )
     {
-        if(info.objectType != expectedType) {
-            revert ErrorContractLibComponentTypeMismatch(
+        if(expectedType != COMPONENT()) {
+            if(info.objectType != expectedType) {
+                revert ErrorContractLibComponentTypeMismatch(
+                    //info.objectAddress,
+                    info.nftId,
+                    expectedType,
+                    info.objectType);
+            }
+        } else if(
+            !(
+                info.objectType == PRODUCT() ||
+                info.objectType == POOL() ||
+                info.objectType == DISTRIBUTION() ||
+                info.objectType == ORACLE()
+            )
+        ) {
+            revert ErrorContractLibCallerNotComponent(
+                //info.objectAddress,
                 info.nftId,
-                expectedType,
                 info.objectType);
         }
 
+        if(info.release != expectedRelease) {
+            revert ErrorContractLibComponentReleaseMismatch(
+                //info.objectAddress,
+                info.nftId,
+                expectedRelease,
+                info.release);
+        }
+
+        componentNftId = info.nftId;
+
         // get instance and check component is active
-        instance = getAndVerifyInstance(registry, info);
+        instance = getAndVerifyInstance(info);
         _checkComponentActive(instance, info.objectAddress, info.nftId, onlyActive);
-
-        return (
-            info,
-            instance
-        );
     }
 
 
     function _checkComponentActive(
-        address instance, 
-        address target, 
+        IInstance instance, 
+        address component, 
         NftId componentNftId, 
         bool onlyActive
     )
@@ -246,11 +514,8 @@ library ContractLib {
         view
     {
         if (onlyActive) {
-            if (IInstanceAdminHelper(
-                instance).getInstanceAdmin().isTargetLocked(
-                    target)
-            ) {
-                revert ErrorContractLibComponentInactive(componentNftId);
+            if (instance.getInstanceAdmin().isTargetLocked(component)) {
+                revert ErrorContractLibComponentInactive(/*component, */componentNftId);
             }
         }
     }
@@ -260,13 +525,14 @@ library ContractLib {
     /// The info may represent a product or any other component.
     /// If the parent of the provided info is not registered with the correct type, the function reverts.
     function getAndVerifyInstance(
-        IRegistry registry,
         IRegistry.ObjectInfo memory info
     )
         public
         view
-        returns (address instance)
+        returns (IInstance instance)
     {
+        IRegistry registry = getRegistry();
+
         // get instance for product case
         if (info.objectType == PRODUCT()) {
             // verify that parent of product is registered instance
@@ -278,7 +544,7 @@ library ContractLib {
             }
 
             // we have verified that parent object is a registerd instance -> we return the instance address
-            return instanceInfo.objectAddress;
+            return IInstance(instanceInfo.objectAddress);
         }
 
         // not product: verify parent is registered product
@@ -290,23 +556,23 @@ library ContractLib {
         }
 
         // we have verified that parent is registerd product -> we can rely on registry that its parent is an instance
-        return registry.getObjectAddress(info.parentNftId);
+        return IInstance(registry.getObjectAddress(info.parentNftId));
     }
 
-
+    // check registration and return info
     function _getAndVerifyObjectInfo(
-        IRegistry registry, 
         address caller
     )
         internal
         view
         returns (IRegistry.ObjectInfo memory info)
     {
-        NftId componentNftId = registry.getNftIdForAddress(caller);
-        if (componentNftId.eqz()) {
+        IRegistry registry = getRegistry();
+
+        info = registry.getObjectInfo(caller);
+
+        if (info.nftId.eqz()) {
             revert ErrorContractLibCallerNotRegistered(caller);
         }
-
-        info = registry.getObjectInfo(componentNftId);
     }
 }

package/contracts/shared/EcdsaChecker.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

package/contracts/shared/IAuthorizedComponent.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IComponent} from "../shared/IComponent.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+
+/// @dev component base class
+/// component examples are product, distribution, pool and oracle
+interface IAuthorizedComponent is 
+    IComponent
+{
+    /// @dev returns the initial component authorization specification.
+    function getAuthorization() external view returns (IAuthorization authorization);
+
+}

package/contracts/shared/IComponent.sol

@@ -29,6 +29,11 @@ interface IComponent is
     event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
     event LogComponentTokenHandlerApproved(address tokenHandler, address token, Amount limit, bool isMaxAmount);
 
+    /// @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
+    function withdrawFees(Amount amount) external returns (Amount withdrawnAmount);
+
     /// @dev returns the name of this component
     /// to successfully register the component with an instance the name MUST be unique in the linked instance
     function getName() external view returns (string memory name);
@@ -43,9 +48,6 @@ interface IComponent is
     /// the default address is the token handler address
     function getWallet() external view returns (address walletAddress);
 
-    /// @dev returns true iff this compoent intercepts nft minting and transfers for objects registered by this component
-    function isNftInterceptor() external view returns(bool isInterceptor);
-
     /// @dev returns true iff this component is registered with the registry
     function isRegistered() external view returns (bool);