@etherisc/gif-next 0.0.2-ebbe63d → 0.0.2-ed4dd55

package/contracts/instance/component/ComponentModule.sol

@@ -0,0 +1,259 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {RegistryLinked} from "../../registry/Registry.sol";
+import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+import {IAccessComponentTypeRoles, IAccessCheckRole} from "../access/IAccess.sol";
+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";
+
+
+abstract contract ComponentModule is 
+    IRegistryLinked,
+    IAccessComponentTypeRoles,
+    IAccessCheckRole,
+    IComponentModule
+{
+
+    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(uint256 cType => bytes32 role) private _componentOwnerRole;
+
+    IComponentOwnerService private _componentOwnerService;
+
+    modifier onlyComponentOwnerService() {
+        require(address(_componentOwnerService) == msg.sender, "ERROR:CMP-001:NOT_OWNER_SERVICE");
+        _;
+    }
+
+    constructor(address componentOwnerService) {
+        _componentOwnerService = ComponentOwnerService(componentOwnerService);
+    }
+
+    function registerComponent(IComponentContract component)
+        external
+        override
+        onlyComponentOwnerService
+        returns(uint256 nftId)
+    {
+        bytes32 typeRole = getRoleForType(component.getType());
+        require(
+            this.hasRole(typeRole, component.getInitialOwner()),
+            "ERROR:CMP-004:TYPE_ROLE_MISSING");
+        
+        nftId = this.getRegistry().register(address(component));
+
+        _componentInfo[nftId] = ComponentInfo(
+            nftId,
+            CState.Active);
+
+        // special case product -> persist product - pool assignment
+        if(component.getType() == this.getRegistry().PRODUCT()) {
+            IProductComponent product = IProductComponent(address(component));
+            uint256 poolNftId = product.getPoolNftId();
+            require(poolNftId > 0, "ERROR:CMP-005:POOL_UNKNOWN");
+            // add more validation (type, token, ...)
+
+            _poolNftIdForProduct[nftId] = poolNftId;
+
+            // add creation of productInfo
+        }
+        else if(component.getType() == this.getRegistry().POOL()) {
+            IPoolModule poolModule = IPoolModule(address(this));
+            poolModule.createPoolInfo(
+                nftId,
+                address(component), // set pool as its wallet
+                address(0) // don't deal with token yet
+            );
+        }
+
+        _idByAddress[address(component)] = nftId;
+        _ids.push(nftId);
+
+        // add logging
+    }
+
+    function getPoolNftId(uint256 productNftId)
+        external
+        view
+        override
+        returns(uint256 poolNftId)
+    {
+        poolNftId = _poolNftIdForProduct[productNftId];
+    }
+
+
+    function getComponentOwnerService()
+        external
+        override
+        view
+        returns(IComponentOwnerService)
+    {
+        return _componentOwnerService;
+    }
+
+    function setComponentInfo(ComponentInfo memory info)
+        external
+        onlyComponentOwnerService
+        returns(uint256 nftId)
+    {
+        uint256 id = info.nftId;
+        require(
+            id > 0 && _componentInfo[id].nftId == id,
+            "ERROR:CMP-005:COMPONENT_UNKNOWN");
+
+        _componentInfo[id] = info;
+
+        // add logging
+    }
+
+    function getComponentInfo(uint256 id)
+        external
+        override
+        view
+        returns(ComponentInfo memory)
+    {
+        return _componentInfo[id];
+    }
+
+    function getComponentOwner(uint256 id)
+        external
+        view
+        returns(address owner)
+    {
+
+    }
+
+    function getComponentId(address componentAddress)
+        external
+        view
+        returns(uint256 id)
+    {
+        return _idByAddress[componentAddress];
+    }
+
+
+    function getComponentId(uint256 idx)
+        external
+        override
+        view
+        returns(uint256 id)
+    {
+        return _ids[idx];
+    }
+
+
+    function components()
+        external
+        override
+        view
+        returns(uint256 numberOfCompnents)
+    {
+        return _ids.length;
+    }
+
+    function getRoleForType(uint256 cType)
+        public
+        view
+        returns(bytes32 role)
+    {
+        if(cType == this.getRegistry().PRODUCT()) {
+            return this.PRODUCT_OWNER_ROLE();
+        }
+        if(cType == this.getRegistry().POOL()) {
+            return this.POOL_OWNER_ROLE();
+        }
+        if(cType == this.getRegistry().ORACLE()) {
+            return this.ORACLE_OWNER_ROLE();
+        }
+
+    }
+}
+
+
+// this is actually the component owner service
+contract ComponentOwnerService is
+    RegistryLinked,
+    IComponent,
+    IComponentOwnerService
+{
+
+    modifier onlyComponentOwner(IComponentContract component) {
+        uint256 nftId = _registry.getNftId(address(component));
+        require(
+            nftId > 0, 
+            "ERROR:COS-001:COMPONENT_UNKNOWN");
+        require(
+            msg.sender == _registry.getOwner(nftId),
+            "ERROR:COS-002:NOT_OWNER"
+        );
+        _;
+    }
+
+    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)
+    {
+        require(
+            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)
+    {
+        IInstance instance = component.getInstance();
+        ComponentInfo memory info = instance.getComponentInfo(component.getNftId());
+        require(info.nftId > 0, "ERROR_COMPONENT_UNKNOWN");
+        // TODO add state change validation
+
+        info.state = CState.Locked;
+        instance.setComponentInfo(info);
+    }
+
+
+    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");
+        // TODO state change validation
+
+        info.state = CState.Active;
+        instance.setComponentInfo(info);
+    }
+
+}

package/contracts/instance/component/IComponent.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+
+import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IInstance} from "../IInstance.sol";
+
+interface IComponent {
+
+    // TODO decide if enum or uints with constants (as in IRegistry.PRODUCT())
+    enum CState {
+        Undefined,
+        Active,
+        Locked
+    }
+
+    // component dynamic info (static info kept in registry)
+    struct ComponentInfo {
+        uint256 nftId;
+        CState state;
+    }
+}
+
+
+interface IInstanceLinked {
+    // function setInstance(address instance) external;
+    function getInstance() external view returns(IInstance instance);
+}
+
+
+interface IComponentContract is
+    IRegisterable,
+    IInstanceLinked,
+    IComponent
+{ }
+
+
+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(uint256 nftInfo);
+
+    function setComponentInfo(ComponentInfo memory info)
+        external
+        returns(uint256 componentId);
+
+    function getComponentInfo(uint256 id)
+        external
+        view
+        returns(ComponentInfo memory info);
+
+    function getComponentOwner(uint256 id)
+        external
+        view
+        returns(address owner);
+
+    function getComponentId(address componentAddress)
+        external
+        view
+        returns(uint256 id);
+
+    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 getComponentOwnerService()
+        external
+        view
+        returns(IComponentOwnerService);
+}

package/contracts/instance/policy/IPolicy.sol

@@ -0,0 +1,66 @@
+// 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";
+
+// TODO check if there is value to introuce IContract and let IPolicy derive from IContract
+interface IPolicy {
+
+    enum PolicyState {
+        Undefined,
+        Applied,
+        Rejected,
+        Active,
+        Closed
+    }
+
+    struct PolicyInfo {
+        uint256 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
+        uint256 closedAt; // no locked capital
+    }
+}
+
+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;
+
+    function getBundleNftForPolicy(uint256 nftId)
+        external
+        view
+        returns(uint256 bundleNft);
+
+    function getPolicyInfo(uint256 nftId)
+        external
+        view
+        returns(PolicyInfo memory info);
+
+}

package/contracts/instance/policy/PolicyModule.sol

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+
+// import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+
+import {IProductService} from "../product/IProductService.sol";
+import {IPolicy, IPolicyModule} from "./IPolicy.sol";
+
+
+abstract contract PolicyModule is
+    IRegistryLinked,
+    IPolicyModule
+{
+
+    mapping(uint256 nftId => PolicyInfo info) private _policyInfo;
+    mapping(uint256 nftId => uint256 bundleNftId) private _bundleForPolicy;
+
+    IProductService private _productService;
+
+    // TODO find a better place to avoid dupliation
+    modifier onlyProductService2() {
+        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
+        _;
+    }
+
+    constructor(address productService) {
+        _productService = IProductService(productService);
+    }
+
+
+    function createApplication(
+        IRegistry.RegistryInfo memory productInfo,
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        uint256 bundleNftId
+    )
+        external
+        override
+        onlyProductService2
+        returns(uint256 nftId)
+    {
+        // TODO add parameter validation
+        if(bundleNftId > 0) {
+            IRegistry.RegistryInfo memory bundleInfo = this.getRegistry().getInfo(bundleNftId);
+            IRegistry.RegistryInfo memory poolInfo = this.getRegistry().getInfo(bundleInfo.parentNftId);
+        }
+
+        nftId = this.getRegistry().registerObjectForInstance(
+            productInfo.nftId,
+            this.getRegistry().POLICY(),
+            applicationOwner);
+
+        _policyInfo[nftId] = PolicyInfo(
+            nftId,
+            PolicyState.Applied,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            block.timestamp,
+            0, // activatedAt
+            0, // expiredAt
+            0 // closedAt
+        );
+
+        _bundleForPolicy[nftId] = bundleNftId;
+
+        // add logging
+    }
+
+
+    function activate(uint256 nftId)
+        external
+        override
+        onlyProductService2
+    {
+        PolicyInfo storage info = _policyInfo[nftId];
+        info.activatedAt = block.timestamp;
+        info.expiredAt = block.timestamp + info.lifetime;
+        info.state = PolicyState.Active;
+
+        // add logging
+    }
+
+
+
+    function getBundleNftForPolicy(uint256 nftId)
+        external
+        view
+        returns(uint256 bundleNft)
+    {
+        return _bundleForPolicy[nftId];
+    }
+
+
+    function getPolicyInfo(uint256 nftId)
+        external
+        view
+        returns(PolicyInfo memory info)
+    {
+        return _policyInfo[nftId];
+    }
+}

package/contracts/instance/pool/IPoolModule.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+
+interface IPool {
+
+    struct PoolInfo {
+        uint256 nftId;
+        address wallet;
+        address token;
+        uint256 capital;
+        uint256 lockedCapital;
+    }
+}
+
+interface IPoolModule is
+    IOwnable,
+    IRegistryLinked,
+    IPool
+{
+    
+    function underwrite(
+        uint256 poolNftId,
+        uint256 policyNftId
+    )
+        external;
+
+    function createPoolInfo(
+        uint256 nftId,
+        address wallet,
+        address token
+    )
+        external;
+
+    function getPoolInfo(uint256 nftId)
+        external
+        view
+        returns(PoolInfo memory info);
+}

package/contracts/instance/pool/PoolModule.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+import {IProductService} from "../product/IProductService.sol";
+import {IPolicy, IPolicyModule} from "../policy/IPolicy.sol";
+import {IPoolModule} from "./IPoolModule.sol";
+
+abstract contract PoolModule is
+    IPoolModule
+{
+    uint256 public constant INITIAL_CAPITAL = 10000*10**6;
+
+    mapping(uint256 nftId => PoolInfo info) private _poolInfo;
+
+    IProductService private _productService;
+
+    modifier onlyProductService() {
+        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
+        _;
+    }
+
+    constructor(address productService) {
+        _productService = IProductService(productService);
+    }
+
+    function createPoolInfo(
+        uint256 nftId,
+        address wallet,
+        address token
+    )
+        public
+        override
+    {
+        require(
+            _poolInfo[nftId].nftId == 0,
+            "ERROR:PL-001:ALREADY_CREATED");
+
+        _poolInfo[nftId] = PoolInfo(
+            nftId,
+            wallet,
+            token,
+            INITIAL_CAPITAL,
+            0 // locked capital
+        );
+
+    }
+
+
+    function underwrite(
+        uint256 poolNftId,
+        uint256 policyNftId
+    )
+        external
+        override
+        onlyProductService
+    {
+        PoolInfo storage poolInfo = _poolInfo[poolNftId];
+        require(
+            poolInfo.nftId == poolNftId,
+            "ERROR:PL-002:POOL_UNKNOWN");
+
+        IPolicyModule policyModule = IPolicyModule(address(this));
+        IPolicy.PolicyInfo memory policyInfo = policyModule.getPolicyInfo(policyNftId);
+
+        require(
+            poolInfo.capital - poolInfo.lockedCapital >= policyInfo.sumInsuredAmount,
+            "ERROR:PL-003:CAPACITY_TOO_LOW");
+
+        poolInfo.lockedCapital += policyInfo.sumInsuredAmount;
+    }
+
+
+    function getPoolInfo(uint256 nftId)
+        external
+        view
+        override
+        returns(PoolInfo memory info)
+    {
+        info = _poolInfo[nftId];
+    }
+
+}

package/contracts/instance/product/IProductService.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+
+import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IInstance} from "../IInstance.sol";
+
+
+// TODO or name this IProtectionService to have Product be something more generic (loan, savings account, ...)
+interface IProductService is
+    IRegistryLinked
+{
+
+    function createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        uint256 bundleNftId
+    )
+        external 
+        returns(uint256 nftId);
+
+    // function revoke(unit256 nftId) external;
+
+    function underwrite(uint256 nftId) external;
+    // function decline(uint256 nftId) external;
+    // function expire(uint256 nftId) external;
+    function close(uint256 nftId) external;
+
+    // function collectPremium(uint256 nftId, uint256 premiumAmount) external;
+
+    // function createClaim(uint256 nftId, uint256 claimAmount) external;
+    // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;
+    // function declineClaim(uint256 nftId, uint256 claimId) external;
+    // function closeClaim(uint256 nftId, uint256 claimId) external;
+}
+
+
+interface IProductModule is
+    IOwnable,
+    IRegistryLinked
+{
+    function getProductService() external view returns(IProductService);
+}