@etherisc/gif-next 3.0.0-dd00d66-173 → 3.0.0-eb61cc5-192

package/contracts/shared/ContractLib.sol

@@ -5,376 +5,114 @@ 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, COMPONENT, PRODUCT, DISTRIBUTION, ORACLE, POOL, POLICY, BUNDLE} from "../type/ObjectType.sol";
-import {TokenRegistry} from "../registry/TokenRegistry.sol";
+import {ObjectType, INSTANCE, PRODUCT, DISTRIBUTION, ORACLE, POOL} from "../type/ObjectType.sol";
 import {VersionPart} from "../type/Version.sol";
 
 interface ITargetHelper {
     function isTargetLocked(address target) external view returns (bool);
 }
 
-library ContractLib {
-
-    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);
-
-    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);
-
-
-
-    // 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);
-    }
+interface IInstanceAdminHelper {
+    function getInstanceAdmin() external view returns (ITargetHelper);
+}
 
-    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});
-    }
+interface ITokenRegistryHelper {
+    function isActive(ChainId chainId, address token, VersionPart release) external view returns (bool);
+}
 
-    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
-        });    
-    }
+library ContractLib {
 
-    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);
-    }
+    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);
 
 
     function getInfoAndInstance(
+        IRegistry registry,
         NftId componentNftId,
-        VersionPart release,
         bool onlyActive
     )
-        public
+        external
         view
         returns (
             IRegistry.ObjectInfo memory info, 
-            IInstance instance
+            address instance
         )
     {
-        IRegistry registry = getRegistry();
         info = registry.getObjectInfo(componentNftId);
-        (, instance) = _getAndVerifyComponentAndInstance(info, info.objectType, release, onlyActive);
+        return _getAndVerifyComponentAndInstance(registry, info, info.objectType, onlyActive);
     }
 
 
-    function getAndVerifyComponent(
+    function getAndVerifyAnyComponent(
+        IRegistry registry, 
         address caller,
-        ObjectType expectedType,
-        VersionPart expectedRelease,
         bool onlyActive
     )
-        public
+        external
         view
         returns (
-            NftId componentNftId, 
-            IInstance instance
+            IRegistry.ObjectInfo memory callerInfo, 
+            address instance
         )
     {
-        // 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);
-        }
-
-        // 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);
-        }
-
-        info = registry.getObjectInfo(info.parentNftId);
-        componentNftId = info.nftId;
-
-        // check parent is component
-        if(info.objectAddress != component) {
-            revert ErrorContractLibObjectParentMismatch(
-                childNftId,
-                registry.getNftIdForAddress(component),
-                info.nftId);
+        // 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);
         }
 
-        // get instance
-        instance = getAndVerifyInstance(info);// _getAndVerifyInstance(info);
-
-        // check component is active
-        _checkComponentActive(
-            instance, 
-            component, 
-            componentNftId, 
-            onlyActive);
+        return _getAndVerifyComponentAndInstance(registry, callerInfo, callerInfo.objectType, 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
+
+    function getAndVerifyComponent(
+        IRegistry registry, 
+        address caller,
+        ObjectType expectedType,
+        bool onlyActive
     )
-        public
+        external
         view
         returns (
-            NftId componentNftId,
-            address objectAddress, // 0 for non contracts objects
-            IInstance instance)
+            IRegistry.ObjectInfo memory info, 
+            address instance
+        )
     {
-        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);
+        info = _getAndVerifyObjectInfo(registry, caller);
+        return _getAndVerifyComponentAndInstance(registry, info, expectedType, 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, 
@@ -385,7 +123,7 @@ library ContractLib {
         view 
         returns (bool)
     {
-        return TokenRegistry(
+        return ITokenRegistryHelper(
             tokenRegistryAddress).isActive(
                 chainId, token, release);
     }
@@ -422,6 +160,16 @@ 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;
@@ -431,8 +179,12 @@ library ContractLib {
     }
 
 
-    function isRegistry(address registry) public pure returns (bool) {
-        return registry == REGISTRY_ADDRESS;
+    function isRegistry(address registry) public view returns (bool) {
+        if (!isContract(registry)) {
+            return false;
+        }
+
+        return supportsInterface(registry, type(IRegistry).interfaceId);
     }
 
 
@@ -454,59 +206,39 @@ library ContractLib {
 
 
     function _getAndVerifyComponentAndInstance(
+        IRegistry registry, 
         IRegistry.ObjectInfo memory info,
         ObjectType expectedType,
-        VersionPart expectedRelease,
         bool onlyActive
     )
         internal
         view
         returns (
-            NftId componentNftId,
-            IInstance instance
+            IRegistry.ObjectInfo memory, 
+            address instance
         )
     {
-        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,
+        if(info.objectType != expectedType) {
+            revert ErrorContractLibComponentTypeMismatch(
                 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(info);
+        instance = getAndVerifyInstance(registry, info);
         _checkComponentActive(instance, info.objectAddress, info.nftId, onlyActive);
+
+        return (
+            info,
+            instance
+        );
     }
 
 
     function _checkComponentActive(
-        IInstance instance, 
-        address component, 
+        address instance, 
+        address target, 
         NftId componentNftId, 
         bool onlyActive
     )
@@ -514,8 +246,11 @@ library ContractLib {
         view
     {
         if (onlyActive) {
-            if (instance.getInstanceAdmin().isTargetLocked(component)) {
-                revert ErrorContractLibComponentInactive(/*component, */componentNftId);
+            if (IInstanceAdminHelper(
+                instance).getInstanceAdmin().isTargetLocked(
+                    target)
+            ) {
+                revert ErrorContractLibComponentInactive(componentNftId);
             }
         }
     }
@@ -525,14 +260,13 @@ 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 (IInstance instance)
+        returns (address instance)
     {
-        IRegistry registry = getRegistry();
-
         // get instance for product case
         if (info.objectType == PRODUCT()) {
             // verify that parent of product is registered instance
@@ -544,7 +278,7 @@ library ContractLib {
             }
 
             // we have verified that parent object is a registerd instance -> we return the instance address
-            return IInstance(instanceInfo.objectAddress);
+            return instanceInfo.objectAddress;
         }
 
         // not product: verify parent is registered product
@@ -556,23 +290,23 @@ library ContractLib {
         }
 
         // we have verified that parent is registerd product -> we can rely on registry that its parent is an instance
-        return IInstance(registry.getObjectAddress(info.parentNftId));
+        return registry.getObjectAddress(info.parentNftId);
     }
 
-    // check registration and return info
+
     function _getAndVerifyObjectInfo(
+        IRegistry registry, 
         address caller
     )
         internal
         view
         returns (IRegistry.ObjectInfo memory info)
     {
-        IRegistry registry = getRegistry();
-
-        info = registry.getObjectInfo(caller);
-
-        if (info.nftId.eqz()) {
+        NftId componentNftId = registry.getNftIdForAddress(caller);
+        if (componentNftId.eqz()) {
             revert ErrorContractLibCallerNotRegistered(caller);
         }
+
+        info = registry.getObjectInfo(componentNftId);
     }
 }

package/contracts/shared/IComponent.sol

@@ -29,11 +29,6 @@ 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);
@@ -48,6 +43,9 @@ 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);
 

package/contracts/shared/IComponentService.sol

@@ -18,11 +18,18 @@ interface IComponentService is
 {
     // registerProduct
     error ErrorComponentServiceCallerNotInstance(address caller);
+    error ErrorComponentServiceNotProduct(address product);
     error ErrorComponentServiceTokenInvalid(address token);
 
     // registerComponent
     error ErrorComponentServiceCallerNotProduct(address caller);
+    error ErrorComponentServiceNotComponent(address component);
+
+    error ErrorComponentServiceNotInstanceLinkedComponent(address component);
     error ErrorComponentServiceComponentTypeNotSupported(address component, ObjectType invalid);
+    error ErrorComponentServiceComponentParentInvalid(address component, NftId required, NftId actual);
+    error ErrorComponentServiceComponentReleaseMismatch(address component, VersionPart serviceRelease, VersionPart componentRelease);
+    error ErrorComponentServiceComponentAlreadyRegistered(address component);
     
     error ErrorProductServiceNoDistributionExpected(NftId productNftId);
     error ErrorProductServiceDistributionAlreadyRegistered(NftId productNftId, NftId distributionNftId);
@@ -30,11 +37,19 @@ interface IComponentService is
     error ErrorProductServiceOraclesAlreadyRegistered(NftId productNftId, uint8 expectedOracles);
     error ErrorProductServicePoolAlreadyRegistered(NftId productNftId, NftId poolNftId);
 
+    error ErrorComponentServiceNewWalletAddressZero();
+    error ErrorComponentServiceWalletAddressZero();
+    error ErrorComponentServiceWalletAddressIsSameAsCurrent();
+
     error ErrorComponentServiceWithdrawAmountIsZero();
     error ErrorComponentServiceWithdrawAmountExceedsLimit(Amount withdrawnAmount, Amount withdrawLimit);
+    error ErrorComponentServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
 
     event LogComponentServiceComponentLocked(address component, bool locked);
+    event LogComponentServiceTokenHandlerDeployed(NftId componentNftId, address tokenHandler, address token);
     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);