@etherisc/gif-next 0.0.2-b9b3e89 → 0.0.2-c4efd5e

package/contracts/instance/access/IAccess.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.19;
 import {IOwnable, IRegistryLinked} from "../../registry/IRegistry.sol";
 
 interface IAccess {
-
     struct RoleInfo {
         bytes32 id;
         string name;
@@ -13,71 +12,52 @@ interface IAccess {
 }
 
 interface IAccessCheckRole {
-
-    function hasRole(bytes32 role, address member)
-        external
-        view
-        returns(bool);
+    function hasRole(bytes32 role, address member) external view returns (bool);
 }
 
 interface IAccessComponentTypeRoles {
-    function PRODUCT_OWNER_ROLE() external view returns(bytes32 role);
-    function ORACLE_OWNER_ROLE() external view returns(bytes32 role);
-    function POOL_OWNER_ROLE() external view returns(bytes32 role);
-}
+    function PRODUCT_OWNER_ROLE() external view returns (bytes32 role);
 
+    function ORACLE_OWNER_ROLE() external view returns (bytes32 role);
 
-interface IAccessModule is 
+    function POOL_OWNER_ROLE() external view returns (bytes32 role);
+}
+
+interface IAccessModule is
     IOwnable,
     IRegistryLinked,
     IAccess,
     IAccessComponentTypeRoles,
     IAccessCheckRole
 {
+    function createRole(string memory roleName) external returns (bytes32 role);
 
-    function createRole(string memory roleName)
-        external
-        returns(bytes32 role);
-
-    function enableRole(bytes32 role)
-        external;       
+    function enableRole(bytes32 role) external;
 
-    function disableRole(bytes32 role)
-        external;       
+    function disableRole(bytes32 role) external;
 
-    function grantRole(bytes32 role, address member)
-        external;       
+    function grantRole(bytes32 role, address member) external;
 
-    function revokeRole(bytes32 role, address member)
-        external;       
+    function revokeRole(bytes32 role, address member) external;
 
-    function getRole(uint256 idx)
-        external
-        view
-        returns(bytes32 role);
+    function getRole(uint256 idx) external view returns (bytes32 role);
 
-    function getRoleInfo(bytes32 role)
-        external
-        view
-        returns(RoleInfo memory info);
+    function getRoleInfo(
+        bytes32 role
+    ) external view returns (RoleInfo memory info);
 
-    function getRoleForName(string memory roleName)
-        external
-        pure
-        returns(bytes32 role);
+    function getRoleForName(
+        string memory roleName
+    ) external pure returns (bytes32 role);
 
-    function getRoleCount()
-        external
-        view
-        returns(uint256 roles);
+    function getRoleCount() external view returns (uint256 roles);
 
-    function getRoleMemberCount(bytes32 role)
-        external
-        view
-        returns(uint256 roleMembers);
+    function getRoleMemberCount(
+        bytes32 role
+    ) external view returns (uint256 roleMembers);
 
-    function getRoleMember(bytes32 role, uint256 idx)
-        external
-        view
-        returns(address roleMembers);
-}
+    function getRoleMember(
+        bytes32 role,
+        uint256 idx
+    ) external view returns (address roleMembers);
+}

package/contracts/instance/component/ComponentModule.sol

@@ -9,26 +9,30 @@ import {IInstance} from "../IInstance.sol";
 import {IComponent, IComponentContract, IComponentModule, IComponentOwnerService} from "./IComponent.sol";
 import {IProductComponent} from "../../components/IProduct.sol";
 import {IPoolModule} from "../pool/IPoolModule.sol";
+import {NftId, NftIdLib} from "../../types/NftId.sol";
 
-
-abstract contract ComponentModule is 
+abstract contract ComponentModule is
     IRegistryLinked,
     IAccessComponentTypeRoles,
     IAccessCheckRole,
     IComponentModule
 {
+    using NftIdLib for NftId;
 
-    mapping(uint256 nftId => ComponentInfo info) private _componentInfo;
-    mapping(uint256 nftId => uint256 poolNftId) private _poolNftIdForProduct;
-    mapping(address cAddress => uint256 id) private _idByAddress;
-    uint256 [] private _ids;
+    mapping(NftId nftId => ComponentInfo info) private _componentInfo;
+    mapping(NftId nftId => NftId poolNftId) private _poolNftIdForProduct;
+    mapping(address cAddress => NftId nftId) private _nftIdByAddress;
+    NftId[] private _nftIds;
 
     mapping(uint256 cType => bytes32 role) private _componentOwnerRole;
 
     IComponentOwnerService private _componentOwnerService;
 
     modifier onlyComponentOwnerService() {
-        require(address(_componentOwnerService) == msg.sender, "ERROR:CMP-001:NOT_OWNER_SERVICE");
+        require(
+            address(_componentOwnerService) == msg.sender,
+            "ERROR:CMP-001:NOT_OWNER_SERVICE"
+        );
         _;
     }
 
@@ -36,35 +40,30 @@ abstract contract ComponentModule is
         _componentOwnerService = ComponentOwnerService(componentOwnerService);
     }
 
-    function registerComponent(IComponentContract component)
-        external
-        override
-        onlyComponentOwnerService
-        returns(uint256 nftId)
-    {
+    function registerComponent(
+        IComponentContract component
+    ) external override onlyComponentOwnerService returns (NftId nftId) {
         bytes32 typeRole = getRoleForType(component.getType());
         require(
             this.hasRole(typeRole, component.getInitialOwner()),
-            "ERROR:CMP-004:TYPE_ROLE_MISSING");
-        
+            "ERROR:CMP-004:TYPE_ROLE_MISSING"
+        );
+
         nftId = this.getRegistry().register(address(component));
 
-        _componentInfo[nftId] = ComponentInfo(
-            nftId,
-            CState.Active);
+        _componentInfo[nftId] = ComponentInfo(nftId, CState.Active);
 
         // special case product -> persist product - pool assignment
-        if(component.getType() == this.getRegistry().PRODUCT()) {
+        if (component.getType() == this.getRegistry().PRODUCT()) {
             IProductComponent product = IProductComponent(address(component));
-            uint256 poolNftId = product.getPoolNftId();
-            require(poolNftId > 0, "ERROR:CMP-005:POOL_UNKNOWN");
+            NftId poolNftId = product.getPoolNftId();
+            require(poolNftId.gtz(), "ERROR:CMP-005:POOL_UNKNOWN");
             // add more validation (type, token, ...)
 
             _poolNftIdForProduct[nftId] = poolNftId;
 
             // add creation of productInfo
-        }
-        else if(component.getType() == this.getRegistry().POOL()) {
+        } else if (component.getType() == this.getRegistry().POOL()) {
             IPoolModule poolModule = IPoolModule(address(this));
             poolModule.createPoolInfo(
                 nftId,
@@ -73,122 +72,96 @@ abstract contract ComponentModule is
             );
         }
 
-        _idByAddress[address(component)] = nftId;
-        _ids.push(nftId);
+        _nftIdByAddress[address(component)] = nftId;
+        _nftIds.push(nftId);
 
         // add logging
     }
 
-    function getPoolNftId(uint256 productNftId)
-        external
-        view
-        override
-        returns(uint256 poolNftId)
-    {
+    function getPoolNftId(
+        NftId productNftId
+    ) external view override returns (NftId poolNftId) {
         poolNftId = _poolNftIdForProduct[productNftId];
     }
 
-
     function getComponentOwnerService()
         external
-        override
         view
-        returns(IComponentOwnerService)
+        override
+        returns (IComponentOwnerService)
     {
         return _componentOwnerService;
     }
 
-    function setComponentInfo(ComponentInfo memory info)
-        external
-        onlyComponentOwnerService
-        returns(uint256 nftId)
-    {
-        uint256 id = info.nftId;
+    function setComponentInfo(
+        ComponentInfo memory info
+    ) external onlyComponentOwnerService returns (NftId nftId) {
+        nftId = info.nftId;
         require(
-            id > 0 && _componentInfo[id].nftId == id,
-            "ERROR:CMP-005:COMPONENT_UNKNOWN");
+            nftId.gtz() && _componentInfo[nftId].nftId.eq(nftId),
+            "ERROR:CMP-006:COMPONENT_UNKNOWN"
+        );
 
-        _componentInfo[id] = info;
+        _componentInfo[nftId] = info;
 
         // add logging
     }
 
-    function getComponentInfo(uint256 id)
-        external
-        override
-        view
-        returns(ComponentInfo memory)
-    {
-        return _componentInfo[id];
+    function getComponentInfo(
+        NftId nftId
+    ) external view override returns (ComponentInfo memory) {
+        return _componentInfo[nftId];
     }
 
-    function getComponentOwner(uint256 id)
-        external
-        view
-        returns(address owner)
-    {
+    function getComponentOwner(
+        NftId nftId
+    ) external view returns (address owner) {}
 
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId componentNftId) {
+        return _nftIdByAddress[componentAddress];
     }
 
-    function getComponentId(address componentAddress)
-        external
-        view
-        returns(uint256 id)
-    {
-        return _idByAddress[componentAddress];
+    function getComponentId(
+        uint256 idx
+    ) external view override returns (NftId componentNftId) {
+        return _nftIds[idx];
     }
 
-
-    function getComponentId(uint256 idx)
-        external
-        override
-        view
-        returns(uint256 id)
-    {
-        return _ids[idx];
-    }
-
-
     function components()
         external
-        override
         view
-        returns(uint256 numberOfCompnents)
+        override
+        returns (uint256 numberOfCompnents)
     {
-        return _ids.length;
+        return _nftIds.length;
     }
 
-    function getRoleForType(uint256 cType)
-        public
-        view
-        returns(bytes32 role)
-    {
-        if(cType == this.getRegistry().PRODUCT()) {
+    function getRoleForType(uint256 cType) public view returns (bytes32 role) {
+        if (cType == this.getRegistry().PRODUCT()) {
             return this.PRODUCT_OWNER_ROLE();
         }
-        if(cType == this.getRegistry().POOL()) {
+        if (cType == this.getRegistry().POOL()) {
             return this.POOL_OWNER_ROLE();
         }
-        if(cType == this.getRegistry().ORACLE()) {
+        if (cType == this.getRegistry().ORACLE()) {
             return this.ORACLE_OWNER_ROLE();
         }
-
     }
 }
 
-
 // this is actually the component owner service
 contract ComponentOwnerService is
     RegistryLinked,
     IComponent,
     IComponentOwnerService
 {
+    using NftIdLib for NftId;
 
     modifier onlyComponentOwner(IComponentContract component) {
-        uint256 nftId = _registry.getNftId(address(component));
-        require(
-            nftId > 0, 
-            "ERROR:COS-001:COMPONENT_UNKNOWN");
+        NftId nftId = _registry.getNftId(address(component));
+        require(nftId.gtz(), "ERROR:COS-001:COMPONENT_UNKNOWN");
         require(
             msg.sender == _registry.getOwner(nftId),
             "ERROR:COS-002:NOT_OWNER"
@@ -196,64 +169,45 @@ contract ComponentOwnerService is
         _;
     }
 
-    constructor(address registry)
-        RegistryLinked(registry)
-    { }
+    constructor(address registry) RegistryLinked(registry) {}
 
-
-    // modifier onlyComponentOwnerRole(IComponentContract component) {
-    //     IInstance instance = component.getInstance();
-    //     // TODO add set/getComponentOwnerRole to IComonentModule
-    //     bytes32 typeRole = instance.getComponentTypeRole(component.getType());
-    //     require(
-    //         instance.hasRole(typeRole, msg.sender),
-    //         "ERROR:COS-003:COMPONENT_ROLE_MISSING"
-    //     );
-    //     _;
-    // }
-
-
-    function register(IComponentContract component)
-        external
-        override
-        returns(uint256 nftId)
-    {
+    function register(
+        IComponentContract component
+    ) external override returns (NftId nftId) {
         require(
-            msg.sender == component.getInitialOwner(), 
-            "ERROR:COS-003:NOT_OWNER");
+            msg.sender == component.getInitialOwner(),
+            "ERROR:COS-003:NOT_OWNER"
+        );
 
         IInstance instance = component.getInstance();
         nftId = instance.registerComponent(component);
     }
 
-
-    function lock(IComponentContract component)
-        external
-        override
-        onlyComponentOwner(component)
-    {
+    function lock(
+        IComponentContract component
+    ) external override onlyComponentOwner(component) {
         IInstance instance = component.getInstance();
-        ComponentInfo memory info = instance.getComponentInfo(component.getNftId());
-        require(info.nftId > 0, "ERROR_COMPONENT_UNKNOWN");
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
         // TODO add state change validation
 
         info.state = CState.Locked;
         instance.setComponentInfo(info);
     }
 
-
-    function unlock(IComponentContract component)
-        external
-        override
-        onlyComponentOwner(component)
-    {
+    function unlock(
+        IComponentContract component
+    ) external override onlyComponentOwner(component) {
         IInstance instance = component.getInstance();
-        ComponentInfo memory info = instance.getComponentInfo(component.getNftId());
-        require(info.nftId > 0, "ERROR_COMPONENT_UNKNOWN");
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
         // TODO state change validation
 
         info.state = CState.Active;
         instance.setComponentInfo(info);
     }
-
-}
+}

package/contracts/instance/component/IComponent.sol

@@ -1,12 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-
 import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
 import {IInstance} from "../IInstance.sol";
+import {NftId} from "../../types/NftId.sol";
 
 interface IComponent {
-
     // TODO decide if enum or uints with constants (as in IRegistry.PRODUCT())
     enum CState {
         Undefined,
@@ -16,79 +15,59 @@ interface IComponent {
 
     // component dynamic info (static info kept in registry)
     struct ComponentInfo {
-        uint256 nftId;
+        NftId nftId;
         CState state;
     }
 }
 
-
 interface IInstanceLinked {
     // function setInstance(address instance) external;
-    function getInstance() external view returns(IInstance instance);
+    function getInstance() external view returns (IInstance instance);
 }
 
+interface IComponentContract is IRegisterable, IInstanceLinked, IComponent {}
 
-interface IComponentContract is
-    IRegisterable,
-    IInstanceLinked,
-    IComponent
-{ }
+interface IComponentOwnerService is IRegistryLinked {
+    function register(
+        IComponentContract component
+    ) external returns (NftId nftId);
 
-
-interface IComponentOwnerService is IRegistryLinked{
-
-    function register(IComponentContract component) external returns(uint256 id);
     function lock(IComponentContract component) external;
+
     function unlock(IComponentContract component) external;
 }
 
+interface IComponentModule is IOwnable, IRegistryLinked, IComponent {
+    function registerComponent(
+        IComponentContract component
+    ) external returns (NftId nftId);
 
-interface IComponentModule is
-    IOwnable,
-    IRegistryLinked,
-    IComponent
-{
+    function setComponentInfo(
+        ComponentInfo memory info
+    ) external returns (NftId componentNftId);
 
-    function registerComponent(IComponentContract component)
-        external
-        returns(uint256 nftInfo);
+    function getComponentInfo(
+        NftId nftId
+    ) external view returns (ComponentInfo memory info);
 
-    function setComponentInfo(ComponentInfo memory info)
-        external
-        returns(uint256 componentId);
+    function getComponentOwner(
+        NftId nftId
+    ) external view returns (address owner);
 
-    function getComponentInfo(uint256 id)
-        external
-        view
-        returns(ComponentInfo memory info);
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId nftId);
 
-    function getComponentOwner(uint256 id)
-        external
-        view
-        returns(address owner);
+    function getComponentId(uint256 idx) external view returns (NftId nftId);
 
-    function getComponentId(address componentAddress)
-        external
-        view
-        returns(uint256 id);
+    function getPoolNftId(
+        NftId productNftId
+    ) external view returns (NftId poolNftId);
 
-    function getComponentId(uint256 idx)
-        external
-        view
-        returns(uint256 id);
-
-    function getPoolNftId(uint256 productNftId)
-        external
-        view
-        returns(uint256 poolNftId);
-
-    function components()
-        external
-        view
-        returns(uint256 numberOfCompnents);
+    function components() external view returns (uint256 numberOfCompnents);
 
     function getComponentOwnerService()
         external
         view
-        returns(IComponentOwnerService);
-}
+        returns (IComponentOwnerService);
+}

package/contracts/instance/policy/IPolicy.sol

@@ -1,15 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-
 import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
 import {IInstance} from "../IInstance.sol";
-
 import {IProductService} from "../product/IProductService.sol";
+import {NftId} from "../../types/NftId.sol";
 
 // TODO check if there is value to introuce IContract and let IPolicy derive from IContract
 interface IPolicy {
-
     enum PolicyState {
         Undefined,
         Applied,
@@ -19,13 +17,11 @@ interface IPolicy {
     }
 
     struct PolicyInfo {
-        uint256 nftId;
+        NftId nftId;
         PolicyState state; // applied, withdrawn, rejected, active, closed
-
         uint256 sumInsuredAmount;
         uint256 premiumAmount;
         uint256 lifetime; // activatedAt + lifetime >= expiredAt
-
         uint256 createdAt;
         uint256 activatedAt; // time of underwriting
         uint256 expiredAt; // no new claims
@@ -33,34 +29,23 @@ interface IPolicy {
     }
 }
 
-interface IPolicyModule is
-    IOwnable,
-    IRegistryLinked,
-    IPolicy
-{
-
+interface IPolicyModule is IOwnable, IRegistryLinked, IPolicy {
     function createApplication(
         IRegistry.RegistryInfo memory productInfo,
         address applicationOwner,
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
-        uint256 bundleNftId
-    )
-        external
-        returns(uint256 nftId);
-
-    function activate(uint256 nftId)
-        external;
+        NftId bundleNftId
+    ) external returns (NftId nftId);
 
-    function getBundleNftForPolicy(uint256 nftId)
-        external
-        view
-        returns(uint256 bundleNft);
+    function activate(NftId nftId) external;
 
-    function getPolicyInfo(uint256 nftId)
-        external
-        view
-        returns(PolicyInfo memory info);
+    function getBundleNftForPolicy(
+        NftId nftId
+    ) external view returns (NftId bundleNft);
 
+    function getPolicyInfo(
+        NftId nftId
+    ) external view returns (PolicyInfo memory info);
 }