@etherisc/gif-next 0.0.2-7c3106f-930 → 0.0.2-7c515fb-081

package/contracts/registry/RegistryService.sol

@@ -1,9 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 
 import {IRegistry} from "./IRegistry.sol";
@@ -22,29 +20,29 @@ import {Versionable} from "../../contracts/shared/Versionable.sol";
 import {IRegisterable} from "../../contracts/shared/IRegisterable.sol";
 
 import {RoleId, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE, ORACLE_OWNER_ROLE} from "../../contracts/types/RoleId.sol";
-import {ObjectType, REGISTRY, TOKEN, SERVICE, PRODUCT, ORACLE, POOL, TOKEN, INSTANCE, DISTRIBUTION, POLICY, BUNDLE} from "../../contracts/types/ObjectType.sol";
+import {ObjectType, REGISTRY, SERVICE, PRODUCT, ORACLE, POOL, INSTANCE, DISTRIBUTION, POLICY, BUNDLE} from "../../contracts/types/ObjectType.sol";
 import {StateId, ACTIVE, PAUSED} from "../../contracts/types/StateId.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../contracts/types/NftId.sol";
 import {Fee, FeeLib} from "../../contracts/types/Fee.sol";
 import {Version, VersionPart, VersionLib} from "../../contracts/types/Version.sol";
 
-import {ServiceBase} from "../../contracts/instance/base/ServiceBase.sol";
-import {IService} from "../../contracts/instance/base/IService.sol";
+import {Service} from "../shared/Service.sol";
+import {IService} from "../shared/IService.sol";
 import {IRegistryService} from "./IRegistryService.sol";
 import {Registry} from "./Registry.sol";
 import {ChainNft} from "./ChainNft.sol";
 
 contract RegistryService is
     AccessManagedUpgradeable,
-    ServiceBase,
+    Service,
     IRegistryService
 {
     using NftIdLib for NftId;
 
+    // TODO move errors to interface contract
     error SelfRegistration();
     error NotRegistryOwner();
 
-    error NotToken();
     error NotService();
     error NotInstance();
     error NotProduct();
@@ -58,7 +56,6 @@ contract RegistryService is
     error InvalidInitialOwner(address initialOwner);
     error InvalidAddress(address registerableAddress);
 
-
     // Initial value for constant variable has to be compile-time constant
     // TODO define types as constants?
     //ObjectType public constant SERVICE_TYPE = REGISTRY(); 
@@ -69,48 +66,6 @@ contract RegistryService is
 
     address public constant NFT_LOCK_ADDRESS = address(0x1);
 
-    /// @dev 
-    //  msg.sender - ONLY registry owner
-    //      CAN NOT register itself
-    //      CAN NOT register IRegisterable address
-    //      CAN register ONLY valid object-parent types combinations for TOKEN
-    // IMPORTANT: MUST NOT call untrusted contract inbetween calls to registry/instance (trusted contracts)
-    // motivation: registry/instance state may change during external call
-    // TODO it may be usefull to have transferable token nft in order to delist token, make it invalid for new beginings
-    // TODO: MUST prohibit registration of precompiles addresses
-    function registerToken(address tokenAddress)
-        external 
-        returns(NftId nftId) 
-    {
-        if(msg.sender == tokenAddress) {
-            revert SelfRegistration();
-        }    
-
-        // MUST not revert if no ERC165 support
-        if(tokenAddress.code.length == 0 ||
-            ERC165Checker.supportsInterface(tokenAddress, type(IRegisterable).interfaceId)) {
-            revert NotToken();
-        }
-
-        NftId registryNftId = _registry.getNftId(address(_registry));
-
-        if(msg.sender != _registry.ownerOf(registryNftId)) {
-            revert NotRegistryOwner();
-        }
-
-        IRegistry.ObjectInfo memory info = IRegistry.ObjectInfo(
-            zeroNftId(), // any value
-            registryNftId, // parent nft id
-            TOKEN(),
-            false, // isInterceptor
-            tokenAddress,
-            NFT_LOCK_ADDRESS,
-            "" // any value
-        );
-
-        nftId = _registry.register(info);
-    }
-
     /// @dev 
     //  msg.sender - ONLY registry owner
     //      CAN NOT register itself
@@ -289,7 +244,7 @@ contract RegistryService is
 
 
     // From IService
-    function getName() public pure override(IService, ServiceBase) returns(string memory) {
+    function getName() public pure override(IService, Service) returns(string memory) {
         return NAME;
     }
     //function getType() public pure override(IService, ServiceBase) returns(ObjectType serviceType) {
@@ -333,7 +288,7 @@ contract RegistryService is
 
         NftId registryNftId = registry.getNftId(address(registry));
 
-        _initializeServiceBase(address(registry), registryNftId, owner);
+        _initializeService(address(registry), owner);
 
         // TODO why do registry service proxy need to keep its nftId??? -> no registryServiceNftId checks in implementation
         // if they are -> use registry address to obtain owner of registry service nft (works the same with any registerable and(or) implementation)
@@ -366,8 +321,13 @@ contract RegistryService is
 
         address owner = info.initialOwner;
 
-        if(owner != expectedOwner) { // registerable owner protection
-            revert NotRegisterableOwner(expectedOwner);
+        // solhint-disable-next-line 
+        if(expectedType == INSTANCE()) { 
+            // any address may create a new instance via instance service
+        } else {
+            if(owner != expectedOwner) { // registerable owner protection
+                revert NotRegisterableOwner(expectedOwner);
+            }
         }
 
         if(owner == address(registerable)) {

package/contracts/registry/RegistryServiceManager.sol

@@ -9,6 +9,7 @@ import {Registry} from "./Registry.sol";
 import {IVersionable} from "../shared/IVersionable.sol";
 import {ProxyManager} from "../shared/ProxyManager.sol";
 import {RegistryService} from "./RegistryService.sol";
+import {TokenRegistry} from "./TokenRegistry.sol";
 
 
 contract RegistryServiceManager is
@@ -16,9 +17,9 @@ contract RegistryServiceManager is
 {
     bytes32 constant public ACCESS_MANAGER_CREATION_CODE_HASH = 0x0;
 
-    RegistryService private _registryService; 
-
     AccessManager private _accessManager;
+    RegistryService private _registryService; 
+    TokenRegistry private _tokenRegistry;
 
     /// @dev initializes proxy manager with registry service implementation and deploys registry
     constructor(
@@ -41,11 +42,26 @@ contract RegistryServiceManager is
             address(_registryService.getRegistry()),
             address(_registryService));
 
+        // deploy token registry
+
+        // _tokenRegistry = new TokenRegistry(
+        //     address(_registryService.getRegistry()),
+        //     address(_registryService));
+
         // implies that after this constructor call only upgrade functionality is available
         _isDeployed = true;
     }
 
     //--- view functions ----------------------------------------------------//
+
+    function getAccessManager()
+        external
+        view
+        returns (AccessManager)
+    {
+        return _accessManager;
+    }
+
     function getRegistryService()
         external
         view
@@ -54,11 +70,11 @@ contract RegistryServiceManager is
         return _registryService;
     }
 
-    function getAccessManager()
+    function getTokenRegistry()
         external
         view
-        returns (AccessManager)
+        returns (TokenRegistry)
     {
-        return _accessManager;
+        return _tokenRegistry;
     }
 }

package/contracts/registry/TokenRegistry.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+
+import {IRegisterable} from "../shared/IRegisterable.sol";
+import {IRegistry} from "./IRegistry.sol";
+import {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
+import {NftOwnable} from "../shared/NftOwnable.sol";
+
+/// @title contract to register token per GIF major release.
+contract TokenRegistry is
+    NftOwnable
+{
+
+    string public constant REGISTRY_SERVICE_NAME = "RegistryService";
+
+    event LogRegistered(address token, string symbol, uint256 decimals);
+    event LogTokenStateSet(address token, VersionPart majorVersion, bool active);
+
+    error NotContract(address account);
+    error NotToken(address account);
+    error TokenDecimalsZero();
+    error TokenMajorVersionInvalid(VersionPart majorVersion);
+
+    address [] internal _token;
+    mapping(address token => bool registered) internal _registered;
+    mapping(address token => mapping(VersionPart majorVersion => bool isActive)) internal _active;
+
+    constructor()
+        NftOwnable()
+    { }
+
+
+    /// @dev link ownership of token registry to nft owner of registry service
+    function linkToNftOwnable(address registryAddress) 
+        external
+        onlyOwner
+    {
+        IRegistry registry = IRegistry(registryAddress);
+        address registryServiceAddress = registry.getServiceAddress(REGISTRY_SERVICE_NAME, registry.getMajorVersion());
+
+        _linkToNftOwnable(registryAddress, registryServiceAddress);
+    }
+
+    /// @dev token state is informative, registry have no clue about used tokens
+    // component owner is responsible for token selection and operations
+    // service MUST deny registration of component with inactive token 
+    function setActive(address token, VersionPart majorVersion, bool active)
+        external
+        onlyOwner
+    {
+        // verify that token is registered
+        if (!_registered[token]) {
+            _registerToken(token);
+        }
+
+        // verify valid major version
+        // ensure major version increments is one
+        uint256 version = majorVersion.toInt();
+        if (version < _registry.getMajorVersionMin().toInt() || version > _registry.getMajorVersionMax().toInt()) {
+            revert TokenMajorVersionInvalid(majorVersion);
+        }
+
+        _active[token][majorVersion] = active;
+
+        emit LogTokenStateSet(token, majorVersion, active);
+    }
+
+    function tokens() external view returns (uint256) {
+        return _token.length;
+    }
+
+    function getToken(uint256 idx) external view returns (IERC20Metadata token) {
+        return IERC20Metadata(_token[idx]);
+    }
+
+    function isRegistered(address token) external view returns (bool) {
+        return _registered[token];
+    }
+
+     function isActive(address token, VersionPart majorVersion) external view returns (bool) {
+        return _active[token][majorVersion];
+    }
+
+    /// @dev some sanity checks to prevent unintended registration
+    function _registerToken(address token) internal {
+
+        // MUST be contract
+        if(token.code.length == 0) {
+            revert NotContract(token);
+        }
+
+        // MUST not be GIF registerable
+        if(ERC165Checker.supportsInterface(token, type(IRegisterable).interfaceId)) {
+            revert NotToken(token);
+        }
+
+        // MUST have decimals > 0
+        IERC20Metadata erc20 = IERC20Metadata(token);
+        if(erc20.decimals() == 0) {
+            revert TokenDecimalsZero();
+        }
+
+        _registered[token] = true;
+        _token.push(token);
+
+        emit LogRegistered(token, erc20.symbol(), erc20.decimals());
+    }
+}

package/contracts/shared/ERC165.sol

@@ -7,14 +7,18 @@ contract ERC165 is IERC165 {
     mapping(bytes4 => bool) private _isSupported;
 
     constructor() {
-        // register support for ERC165
-        _registerInterface(type(IERC165).interfaceId);
+        _initializeERC165();
     }
 
     function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
         return _isSupported[interfaceId];
     }
 
+    // @dev register support for ERC165 itself
+    function _initializeERC165() internal {
+        _isSupported[type(IERC165).interfaceId] = true;
+    }
+
     function _registerInterface(bytes4 interfaceId) internal {
         _isSupported[interfaceId] = true;
     }

package/contracts/{instance/base → shared}/IService.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {VersionPart} from "../../types/Version.sol";
+import {VersionPart} from "../types/Version.sol";
 
-import {IRegisterable} from "../../shared/IRegisterable.sol";
-import {IVersionable} from "../../shared/IVersionable.sol";
+import {IRegisterable} from "./IRegisterable.sol";
+import {IVersionable} from "./IVersionable.sol";
 
 interface IService is 
     IRegisterable,

package/contracts/shared/Registerable.sol

@@ -49,6 +49,7 @@ contract Registerable is
         //onlyInitializing//TODO uncomment when "fully" upgradeable
         virtual
     {
+        _initializeERC165();
         _initializeNftOwnable(
             initialOwner,
             registryAddress);

package/contracts/shared/RegisterableUpgradable.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Registerable} from "./Registerable.sol";
+import {Versionable} from "./Versionable.sol";
+
+/// @dev base contract for upgradable objects like services and upgradable components
+/// deriving contracs need to call _initializeRegisterable
+/// TODO internalizes versionable here, a non-registerable versionalbe might itself have some value but is outside the scope of the gif
+/// after this merge versionable will no longer exist on its own in gif
+/// only registerable and upgradable (which is a registerable too) will remain
+abstract contract RegisterableUpgradable is 
+    Registerable,
+    Versionable
+{
+}

package/contracts/shared/Service.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IService} from "./IService.sol";
+import {IVersionable} from "./IVersionable.sol";
+import {NftId, zeroNftId} from "../types/NftId.sol";
+import {RegisterableUpgradable} from "./RegisterableUpgradable.sol";
+import {SERVICE} from "../types/ObjectType.sol";
+import {Version, VersionPart, VersionLib} from "../types/Version.sol";
+import {Versionable} from "./Versionable.sol";
+
+/// @dev service base contract
+abstract contract Service is 
+    RegisterableUpgradable,
+    IService
+{
+    function getName() public pure virtual override returns(string memory name);
+
+    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
+        return getVersion().toMajorPart(); 
+    }
+
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(3,0,0);
+    }
+
+    function _initializeService(
+        address registry, 
+        address initialOwner
+    )
+        internal
+        //onlyInitializing //TODO uncomment when "fully" upgradeable
+    {
+        // service must provide its name and version upon registration
+        bytes memory data = abi.encode(getName(), getMajorVersion());
+        NftId registryNftId = _getRegistryNftId(registry); 
+        bool isInterceptor = false;
+
+        _initializeRegisterable(registry, registryNftId, SERVICE(), isInterceptor, initialOwner, data);
+        _registerInterface(type(IService).interfaceId);
+    }
+
+    // this is just a conveniene function, actual validation will be done upon registration
+    function _getRegistryNftId(address registryAddress) internal view returns (NftId) {
+        return IRegistry(registryAddress).getNftId(registryAddress);
+    }
+}

package/contracts/test/TestService.sol

@@ -3,21 +3,19 @@ pragma solidity ^0.8.19;
 
 import {NftId} from "../../contracts/types/NftId.sol";
 import {Version, VersionLib} from "../../contracts/types/Version.sol";
-import {ServiceBase} from "../../contracts/instance/base/ServiceBase.sol";
+import {Service} from "../../contracts/shared/Service.sol";
 
 import {IVersionable} from "../../contracts/shared/IVersionable.sol";
 import {Versionable} from "../../contracts/shared/Versionable.sol";
 
-//import {IService} from "../../contracts/instance/base/IService.sol";
-
-contract TestService is ServiceBase {
+contract TestService is Service {
 
     string public constant NAME = "TestService";
 
     constructor(address registry, NftId registryNftId, address initialOwner)
     // solhint-disable-next-line no-empty-blocks
     {
-        _initializeServiceBase(registry, registryNftId, initialOwner);
+        _initializeService(registry, initialOwner);
     }
 
     function getName() public pure override returns(string memory name) {

package/contracts/types/RoleId.sol

@@ -22,6 +22,8 @@ function ORACLE_OWNER_ROLE_NAME() pure returns (string memory) { return "OracleO
 function POOL_OWNER_ROLE_NAME() pure returns (string memory) { return "PoolOwnerRole"; }
 function PRODUCT_OWNER_ROLE_NAME() pure returns (string memory) { return "ProductOwnerRole"; }
 
+function ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(0); }
+
 // TODO correct numbers (maybe they are already defined in RegistryService)
 function DISTRIBUTION_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(100); }
 function ORACLE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(200); }
@@ -34,6 +36,11 @@ function BUNDLE_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRole
 function POOL_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1300); }
 function PRODUCT_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1400); }
 
+function DISTRIBUTION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10000); }
+function POOL_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10100); }
+
+function INSTANCE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(11000); }
+
 // @dev Returns true iff role ids a and b are identical
 function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {
     return RoleId.unwrap(a) == RoleId.unwrap(b);

package/contracts/types/StateId.sol

@@ -58,6 +58,10 @@ function PAID() pure returns (StateId) {
     return toStateId(220);
 }
 
+function KEEP_STATE() pure returns (StateId) {
+    return toStateId(type(uint8).max);
+}
+
 /// @dev Converts the uint8 to a StateId.
 function toStateId(uint256 id) pure returns (StateId) {
     return StateId.wrap(uint8(id));

package/contracts/types/Version.sol

@@ -6,15 +6,18 @@ type VersionPart is uint8;
 using {
     versionPartGt as >,
     versionPartEq as ==,
+    versionPartNe as !=,
     VersionPartLib.toInt
 }
     for VersionPart global;
 
 function versionPartGt(VersionPart a, VersionPart b) pure returns(bool isGreaterThan) { return VersionPart.unwrap(a) > VersionPart.unwrap(b); }
 function versionPartEq(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) == VersionPart.unwrap(b); }
+function versionPartNe(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) != VersionPart.unwrap(b); }
 
 library VersionPartLib {
-    function toInt(VersionPart x) external pure returns(uint) { return VersionPart.unwrap(x); }
+    function toInt(VersionPart a) external pure returns(uint) { return VersionPart.unwrap(a); }
+    function toVersionPart(uint256 a) external pure returns(VersionPart) { return VersionPart.wrap(uint8(a)); }
 }
 
 type Version is uint24; // contains major,minor,patch version parts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-7c3106f-930",
+  "version": "0.0.2-7c515fb-081",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {

package/artifacts/contracts/instance/base/IService.sol/IService.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/87bb0e6336af67aff324941d5e57b181.json"
-}

package/artifacts/contracts/instance/base/ServiceBase.sol/ServiceBase.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/87bb0e6336af67aff324941d5e57b181.json"
-}

package/contracts/instance/base/ServiceBase.sol

@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-
-import {NftId, zeroNftId} from "../../types/NftId.sol";
-import {ObjectType, SERVICE} from "../../types/ObjectType.sol";
-import {Version, VersionPart, VersionLib} from "../../types/Version.sol";
-
-import {Registerable} from "../../shared/Registerable.sol";
-import {IRegistry} from "../../registry/IRegistry.sol";
-import {IVersionable} from "../../shared/IVersionable.sol";
-import {Versionable} from "../../shared/Versionable.sol";
-
-import {IService} from "./IService.sol";
-
-abstract contract ServiceBase is 
-    Registerable,
-    Versionable,
-    IService
-{
-    function getName() public pure virtual override returns(string memory name);
-
-    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
-        return getVersion().toMajorPart(); 
-    }
-
-    // from Versionable
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
-    {
-        return VersionLib.toVersion(3,0,0);
-    }
-
-    function _initializeServiceBase(address registry, NftId registryNftId, address initialOwner)
-        internal 
-        //onlyInitializing //TODO uncomment when "fully" upgradeable
-    {// service must provide its name and version upon registration
-        bytes memory data = abi.encode(getName(), getMajorVersion());
-        _initializeRegisterable(registry, registryNftId, SERVICE(), false, initialOwner, data);
-        _registerInterface(type(IService).interfaceId);
-    }
-}