@etherisc/gif-next 0.0.2-d13bb9e-069 → 0.0.2-d18e1c5-511

package/contracts/shared/InitializableERC165.sol

@@ -11,13 +11,21 @@ contract InitializableERC165 is
     mapping(bytes4 => bool) private _isSupported;
 
     // @dev initializes with support for ERC165
-    function _initializeERC165() internal onlyInitializing() {
+    function __ERC165_init() internal onlyInitializing() {
+        _initializeERC165();
+    }
+
+    function _initializeERC165() internal {
         _isSupported[type(IERC165).interfaceId] = true;
     }
 
     // @dev register support for provided interfaceId
     // includes initialization for ERC165_ID if not yet done
     function _registerInterface(bytes4 interfaceId) internal onlyInitializing() {
+        _registerInterfaceNotInitializing(interfaceId);
+    }
+
+    function _registerInterfaceNotInitializing(bytes4 interfaceId) internal{
         _isSupported[interfaceId] = true;
     }
 

package/contracts/shared/InstanceLinkedComponent.sol

@@ -1,27 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-import {Amount} from "../type/Amount.sol";
-import {Component} from "./Component.sol";
-import {IComponentService} from "./IComponentService.sol";
-import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IComponentService} from "./IComponentService.sol";
 import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IOracleService} from "../oracle/IOracleService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {Component} from "./Component.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, INSTANCE} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.sol";
+import {ObjectType, COMPONENT, INSTANCE, ORACLE, PRODUCT} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
 import {RoleId, RoleIdLib} from "../type/RoleId.sol";
-import {IAccess} from "../instance/module/IAccess.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 import {VersionPart} from "../type/Version.sol";
 
 // then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
@@ -38,91 +35,163 @@ abstract contract InstanceLinkedComponent is
         InstanceReader _instanceReader; // instance reader for this component
         IAuthorization _initialAuthorization;
         IComponentService _componentService;
+        IOracleService _oracleService;
     }
 
-    function lock() external onlyOwner {
-        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(true);
-    }
-    
-    function unlock() external onlyOwner {
-        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(false);
-    }
+    //--- view functions ----------------------------------------------------//
 
-    function getInstance() public view override returns (IInstance instance) {
+    /// @inheritdoc IInstanceLinkedComponent
+    function getInstance() public view virtual override returns (IInstance instance) {
         return _getInstanceLinkedComponentStorage()._instance;
     }
 
-    function getProductNftId() public view override returns (NftId productNftId) {
-        return getComponentInfo().productNftId;
-    }
 
-    function getAuthorization() external view returns (IAuthorization authorization) {
+    /// @inheritdoc IInstanceLinkedComponent
+    function getAuthorization() external view virtual returns (IAuthorization authorization) {
         return _getInstanceLinkedComponentStorage()._initialAuthorization;
     }
 
+
     /// @inheritdoc IInstanceLinkedComponent
     function withdrawFees(Amount amount)
         external
         virtual
-        onlyOwner()
         restricted()
+        onlyOwner()
         returns (Amount withdrawnAmount)
     {
         return _withdrawFees(amount);
     }
 
+    //--- internal functions ------------------------------------------------//
+
+    function _sendRequest(
+        NftId oracleNftId,
+        bytes memory requestData,
+        Timestamp expiryAt,
+        string memory callbackMethod
+    )
+        internal
+        virtual
+        returns (RequestId requestId)
+    {
+        return _getInstanceLinkedComponentStorage()._oracleService.request(
+            oracleNftId,
+            requestData,
+            expiryAt,
+            callbackMethod);
+    }
+
+
+    function _cancelRequest(RequestId requestId)
+        internal
+        virtual
+    {
+        _getInstanceLinkedComponentStorage()._oracleService.cancel(requestId);
+    }
+
+
+    function _resendRequest(RequestId requestId)
+        internal
+        virtual
+    {
+        _getInstanceLinkedComponentStorage()._oracleService.resend(requestId);
+    }
+
+
     function _getInstanceLinkedComponentStorage() private pure returns (InstanceLinkedComponentStorage storage $) {
         assembly {
             $.slot := INSTANCE_LINKED_COMPONENT_LOCATION_V1
         }
     }
 
-    function _initializeInstanceLinkedComponent(
+
+    function __InstanceLinkedComponent_init(
         address registry,
-        NftId instanceNftId,
+        NftId parentNftId,
         string memory name,
-        address token,
         ObjectType componentType,
         IAuthorization authorization,
         bool isInterceptor,
-        address initialOwner,
-        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
-        bytes memory componentData // data that will saved with the component info in the instance store
+        address initialOwner
     )
         internal
         virtual
         onlyInitializing()
     {
+        // validate registry, nft ids and get parent nft id
+        NftId instanceNftId = _checkAndGetInstanceNftId(
+            registry, 
+            parentNftId, 
+            componentType);
+
         // set and check linked instance
         InstanceLinkedComponentStorage storage $ = _getInstanceLinkedComponentStorage();
         $._instance = IInstance(
             IRegistry(registry).getObjectAddress(instanceNftId));
 
-        if(!$._instance.supportsInterface(type(IInstance).interfaceId)) {
-            revert ErrorComponentNotInstance(instanceNftId);
-        }
-
-        _initializeComponent(
-            $._instance.authority(), 
+        // set component specific parameters
+        __Component_init(
+            $._instance.authority(), // instance linked components need to point to instance admin
             registry, 
-            instanceNftId, 
+            parentNftId, 
             name, 
-            token,
             componentType, 
             isInterceptor, 
             initialOwner, 
-            registryData,
-            componentData);
+            ""); // registry data
 
-        // set component state
+        // set instance linked specific parameters
         $._instanceReader = $._instance.getInstanceReader();
         $._initialAuthorization = authorization;
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE()));
 
-        _registerInterface(type(IAccessManaged).interfaceId);
+        // register interfaces
         _registerInterface(type(IInstanceLinkedComponent).interfaceId);
     }
 
+
+    function _checkAndGetInstanceNftId(
+        address registryAddress,
+        NftId parentNftId,
+        ObjectType componentType
+    )
+        internal
+        view
+        returns (NftId instanceNftId)
+    {
+        // if product, then parent is already instance
+        if (componentType == PRODUCT()) {
+            _checkAndGetRegistry(registryAddress, parentNftId, INSTANCE());
+            return parentNftId;
+        }
+
+        // if not product parent is product, and parent of product is instance
+        IRegistry registry = _checkAndGetRegistry(registryAddress, parentNftId, PRODUCT());
+        return registry.getParentNftId(parentNftId);
+    }
+
+    /// @dev checks the and gets registry.
+    /// validates registry using a provided nft id and expected object type.
+    function _checkAndGetRegistry(
+        address registryAddress,
+        NftId objectNftId,
+        ObjectType requiredType
+    )
+        internal
+        view
+        returns (IRegistry registry)
+    {
+        registry = IRegistry(registryAddress);
+        IRegistry.ObjectInfo memory info = registry.getObjectInfo(objectNftId);
+
+        if (info.objectType != requiredType) {
+            revert ErrorInstanceLinkedComponentTypeMismatch(requiredType, info.objectType);
+        }
+    }
+
+
     /// @dev for instance linked components the wallet address stored in the instance store.
     /// updating needs to go throug component service
     function _setWallet(address newWallet) internal virtual override onlyOwner {
@@ -139,7 +208,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;
             }
         }
@@ -160,12 +229,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 majorVersion = _getInstanceLinkedComponentStorage()._instance.getMajorVersion();
-        return getRegistry().getServiceAddress(domain, majorVersion);
-    }
 }

package/contracts/shared/Lifecycle.sol

@@ -49,8 +49,9 @@ abstract contract Lifecycle is
     }
 
     function checkTransition(
+        StateId stateId,
         ObjectType objectType,
-        StateId fromId,
+        StateId expectedFromId,
         StateId toId
     )
         public
@@ -58,12 +59,22 @@ abstract contract Lifecycle is
     {
         // revert if no life cycle support
         if (_initialState[objectType].eqz()) {
-            revert ErrorNoLifecycle(objectType);
+            revert ErrorNoLifecycle(address(this), objectType);
+        }
+
+        // revert if current state is not expected `from` state
+        if(stateId != expectedFromId) {
+            revert ErrorFromStateMissmatch(address(this), objectType, stateId, expectedFromId);
         }
 
         // enforce valid state transition
-        if (!_isValidTransition[objectType][fromId][toId]) {
-            revert ErrorInvalidStateTransition(objectType, fromId, toId);
+        if (!_isValidTransition[objectType][stateId][toId]) {
+            revert ErrorInvalidStateTransition(
+                address(this),
+                objectType, 
+                stateId, 
+                toId
+            );
         }
     }
 

package/contracts/shared/NftOwnable.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.20;
 import {InitializableERC165} from "./InitializableERC165.sol";
 import {INftOwnable} from "./INftOwnable.sol";
 import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 
 contract NftOwnable is
@@ -27,19 +28,37 @@ contract NftOwnable is
         _;
     }
 
+    modifier onlyNftOwner(NftId nftId) {
+        if(!getRegistry().isOwnerOf(nftId, msg.sender)) {
+            revert ErrorNftOwnableNotOwner(msg.sender);
+        }
+        _;
+    }
+
+    modifier onlyNftOfType(NftId nftId, ObjectType expectedObjectType) {
+        _checkNftType(nftId, expectedObjectType);
+        _;
+    }
+
+    function _checkNftType(NftId nftId, ObjectType expectedObjectType) internal view {
+        if(expectedObjectType.eqz() || !getRegistry().isObjectType(nftId, expectedObjectType)) {
+            revert ErrorNftOwnableInvalidType(nftId, expectedObjectType);
+        }
+    }
+
 
-    /// @dev initialization for upgradable contracts
-    // used in _initializeRegisterable
-    function _initializeNftOwnable(
-        address initialOwner,
-        address registryAddress
+    /// @dev Initialization for upgradable contracts.
+    // used in __Registerable_init, ProxyManager._preDeployChecksAndSetup
+    function __NftOwnable_init(
+        address registry,
+        address initialOwner
     )
         internal
         virtual
         onlyInitializing()
     {
-        _initializeRegistryLinked(registryAddress);
-        _initializeERC165();
+        __ERC165_init();
+        __RegistryLinked_init(registry);
 
         if(initialOwner == address(0)) {
             revert ErrorNftOwnableInitialOwnerZero();
@@ -95,11 +114,14 @@ contract NftOwnable is
 
         $._nftId = getRegistry().getNftIdForAddress(nftOwnableAddress);
 
+        emit LogNftOwnableNftLinkedToAddress($._nftId, getOwner());
+
         return $._nftId;
     }
 
 
     function _getNftOwnableStorage() private pure returns (NftOwnableStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
         assembly {
             $.slot := NFT_OWNABLE_STORAGE_LOCATION_V1
         }

package/contracts/shared/PolicyHolder.sol

@@ -3,12 +3,13 @@ pragma solidity ^0.8.20;
 
 import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 
+import {IPolicyHolder} from "./IPolicyHolder.sol";
+
 import {Amount} from "../type/Amount.sol";
 import {ClaimId} from "../type/ClaimId.sol";
 import {InitializableERC165} from "./InitializableERC165.sol";
-import {IPolicyHolder} from "./IPolicyHolder.sol";
 import {NftId} from "../type/NftId.sol";
-import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 
@@ -29,7 +30,7 @@ contract PolicyHolder is
         virtual
         onlyInitializing()
     {
-        _initializeRegistryLinked(registryAddress);
+        __RegistryLinked_init(registryAddress);
         _initializeERC165();
         _registerInterface(type(IPolicyHolder).interfaceId);
     }

package/contracts/shared/Registerable.sol

@@ -1,16 +1,22 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
+import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
 import {ObjectType} from "../type/ObjectType.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegisterable} from "./IRegisterable.sol";
+import {IRelease} from "../registry/IRelease.sol";
 
-contract Registerable is
+abstract contract Registerable is
+    AccessManagedUpgradeable,
     NftOwnable,
     IRegisterable
 {
@@ -24,46 +30,64 @@ contract Registerable is
         bytes _data;
     }
 
-    function _initializeRegisterable(
-        address registryAddress,
+    modifier onlyActive() {
+        if (!isActive()) {
+            revert ErrorRegisterableNotActive();
+        }
+        _;
+    }
+
+    function __Registerable_init(
+        address authority,
+        address registry,
         NftId parentNftId,
         ObjectType objectType,
         bool isInterceptor,
         address initialOwner,
-        bytes memory registryData // writeonly data that will saved in the object info record of the registry
+        bytes memory data // writeonly data that will saved in the object info record of the registry
     )
         internal
         virtual
         onlyInitializing()
     {
-        _initializeNftOwnable(
-            initialOwner,
-            registryAddress);
-
-        RegisterableStorage storage $;
-        assembly {
-            $.slot := REGISTERABLE_LOCATION_V1
+        if (!ContractLib.isAuthority(authority)) {
+            revert ErrorAuthorityInvalid(authority);
         }
 
+        __AccessManaged_init(authority);
+        __NftOwnable_init(registry, initialOwner);
+
+        RegisterableStorage storage $ = _getRegisterableStorage();
         $._parentNftId = parentNftId;
         $._objectType = objectType;
         $._isInterceptor = isInterceptor;
-        $._data = registryData;
+        $._data = data;
+
+        _registerInterface(type(IAccessManaged).interfaceId);
+    }
+
+
+    /// @inheritdoc IRegisterable
+    function isActive() public virtual view returns (bool active) {
+        return !AccessManagerCloneable(authority()).isTargetClosed(address(this));
+    }
+
+
+    /// @inheritdoc IRelease
+    function getRelease() public virtual view returns (VersionPart release) {
+        return AccessManagerCloneable(authority()).getRelease();
     }
 
 
+    /// @inheritdoc IRegisterable
     function getInitialInfo() 
         public 
         view 
         virtual 
         returns (IRegistry.ObjectInfo memory info) 
     {
-        RegisterableStorage storage $;
-        assembly {
-            $.slot := REGISTERABLE_LOCATION_V1
-        }
-
-        info = IRegistry.ObjectInfo(
+        RegisterableStorage storage $ = _getRegisterableStorage();
+        return IRegistry.ObjectInfo(
             NftIdLib.zero(),
             $._parentNftId,
             $._objectType,
@@ -72,4 +96,11 @@ contract Registerable is
             getOwner(),
             $._data);
     }
+
+
+    function _getRegisterableStorage() private pure returns (RegisterableStorage storage $) {
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
+    }
 }

package/contracts/shared/RegistryLinked.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {ContractLib} from "../shared/ContractLib.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryLinked} from "./IRegistryLinked.sol";
 
@@ -15,26 +17,18 @@ contract RegistryLinked is
 
     /// @dev initialization for upgradable contracts
     // used in _initializeRegisterable
-    function _initializeRegistryLinked(
-        address registryAddress
+    function __RegistryLinked_init(
+        address registry
     )
         internal
         virtual
         onlyInitializing()
     {
-        if (registryAddress.code.length == 0) {
-            revert ErrorNotRegistry(registryAddress);
+        if (!ContractLib.isRegistry(registry)) {
+            revert ErrorNotRegistry(registry);
         }
 
-        _registry = IRegistry(registryAddress);
-
-        try _registry.supportsInterface(type(IRegistry).interfaceId) returns (bool isRegistry) {
-            if (!isRegistry) {
-                revert ErrorNotRegistry(registryAddress);
-            }
-        } catch {
-            revert ErrorNotRegistry(registryAddress);
-        }
+        _registry = IRegistry(registry);
     }
 
 

package/contracts/shared/Service.sol

@@ -1,17 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IService} from "./IService.sol";
 import {IVersionable} from "../upgradeability/IVersionable.sol";
-import {ObjectType, REGISTRY, SERVICE} from "../type/ObjectType.sol";
+import {ObjectType, SERVICE} from "../type/ObjectType.sol";
 import {Registerable} from "./Registerable.sol";
 import {RoleId, RoleIdLib} from "../type/RoleId.sol";
-import {Version, VersionLib, VersionPartLib} from "../type/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
 import {Versionable} from "../upgradeability/Versionable.sol";
 
 
@@ -19,17 +17,13 @@ import {Versionable} from "../upgradeability/Versionable.sol";
 abstract contract Service is 
     Registerable,
     Versionable,
-    AccessManagedUpgradeable,
     ReentrancyGuardUpgradeable,
     IService
 {
 
-    uint8 private constant GIF_MAJOR_VERSION = 3;
-
-
-    function _initializeService(
-        address registry, 
+    function __Service_init(
         address authority, // real authority for registry service adress(0) for other services
+        address registry, 
         address initialOwner
     )
         internal
@@ -38,17 +32,8 @@ abstract contract Service is
     {
         __ReentrancyGuard_init();
 
-        // externally provided authority
-        if(authority != address(0)) {
-            __AccessManaged_init(authority);
-        } else {
-            address registryServiceAddress = _getServiceAddress(REGISTRY());
-
-            // copy authority from already registered registry services
-            __AccessManaged_init(IAccessManaged(registryServiceAddress).authority());
-        }
-
-        _initializeRegisterable(
+        __Registerable_init(
+            authority,
             registry, 
             IRegistry(registry).getNftId(), 
             SERVICE(), 
@@ -56,8 +41,6 @@ abstract contract Service is
             initialOwner, 
             ""); // data
 
-
-        _registerInterface(type(IAccessManaged).interfaceId);
         _registerInterface(type(IService).interfaceId);
     }
 
@@ -65,23 +48,20 @@ abstract contract Service is
         return _getDomain();
     }
 
-    function getRoleId() external virtual pure returns(RoleId serviceRoleId) {
-        return RoleIdLib.roleForTypeAndVersion(_getDomain(), VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+    function getVersion() public pure virtual override (IVersionable, Versionable) returns(Version) {
+        return VersionLib.toVersion(3, 0, 0);
     }
 
-    // from Versionable
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
-    {
-        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
+
+    function getRoleId() external virtual view returns(RoleId serviceRoleId) {
+        return RoleIdLib.toServiceRoleId(_getDomain(), getRelease());
     }
 
+    //--- internal functions --------------------------------------------------------//
     function _getDomain() internal virtual pure returns (ObjectType);
 
+
     function _getServiceAddress(ObjectType domain) internal view returns (address) {
-        return getRegistry().getServiceAddress(domain, VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+        return getRegistry().getServiceAddress(domain, getRelease());
     }
 }