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

package/contracts/instance/product/ProductService.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+
+// import {IProduct} from "../../components/IProduct.sol";
+// import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
+// import {IInstance} from "../IInstance.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IPolicyModule} from "../policy/IPolicy.sol";
+import {RegistryLinked} from "../../registry/Registry.sol";
+import {IProductService, IProductModule} from "./IProductService.sol";
+import {IComponentModule} from "../../instance/component/IComponent.sol";
+import {IPoolModule} from "../../instance/pool/IPoolModule.sol";
+
+// TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
+contract ProductService is
+    RegistryLinked,
+    IProductService
+{
+    constructor(address registry) 
+        RegistryLinked(registry)
+    { }
+
+
+    function createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        uint256 bundleNftId
+    )
+        external 
+        override
+        returns(uint256 nftId)
+    {
+        // same as only registered product
+        uint256 productNftId = _registry.getNftId(msg.sender);
+        require(productNftId > 0, "ERROR_PRODUCT_UNKNOWN");
+        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
+        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
+        require(instanceInfo.nftId > 0, "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
+        nftId = policyModule.createApplication(
+            productInfo,
+            applicationOwner,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId);
+
+        // add logging
+    }
+
+    function underwrite(uint256 nftId)
+        external
+        override
+    {
+        // same as only registered product
+        uint256 productNftId = _registry.getNftId(msg.sender);
+        require(productNftId > 0, "ERROR_PRODUCT_UNKNOWN");
+        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
+        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
+        require(instanceInfo.nftId > 0, "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        // get responsible pool
+        IComponentModule componentModule = IComponentModule(instanceInfo.objectAddress);
+        uint256 poolNftId = componentModule.getPoolNftId(productNftId);
+
+        // lock capital (and update pool accounting)
+        IPoolModule poolModule = IPoolModule(instanceInfo.objectAddress);
+        poolModule.underwrite(
+            poolNftId,
+            nftId);
+
+        // activate policy
+        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
+        policyModule.activate(nftId);
+
+        // add logging
+    }
+
+    function close(uint256 nftId) external override {}
+}
+
+abstract contract ProductModule is
+    IProductModule
+{
+    IProductService private _productService;
+
+    constructor(address productService) {
+        _productService = IProductService(productService);
+    }
+
+    function getProductService() external view returns(IProductService) {
+        return _productService;
+    }
+
+}

package/contracts/registry/IRegistry.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+interface IOwnable {
+    function getOwner() external view returns(address owner);
+}
+
+interface IRegistryLinked {
+
+    event LogDebug(uint256 idx, address module, string comment);
+
+    function getRegistry() external view returns(IRegistry registry);
+}
+
+interface IRegisterable is 
+    IOwnable,
+    IRegistryLinked
+{
+
+    function register() external returns(uint256 nftId);
+    
+    function getNftId() external view returns(uint256 nftId);
+    function getParentNftId() external view returns(uint256 parentNftId);
+    function getType() external view returns(uint256 objectType);
+    function getData() external view returns(bytes memory data);
+    function isRegisterable() external pure returns(bool);
+    function getInitialOwner() external view returns(address initialOwner);
+
+    function isRegistered() external view returns(bool);
+}
+
+
+interface IRegistry {
+
+    struct RegistryInfo {
+        uint256 nftId;
+        uint256 parentNftId;
+        uint256 objectType;
+        address objectAddress;
+        address initialOwner;
+    }
+
+    function TOKEN() external pure returns(uint256);
+    function INSTANCE() external pure returns(uint256);
+    function PRODUCT() external pure returns(uint256);
+    function ORACLE() external pure returns(uint256);
+    function POOL() external pure returns(uint256);
+    function POLICY() external pure returns(uint256);
+    function BUNDLE() external pure returns(uint256);
+
+    function register(address objectAddress) external returns(uint256 nftId);
+    function registerObjectForInstance(
+        uint256 parentNftid,
+        uint256 objectType,
+        address initialOwner
+    )
+        external returns(uint256 nftId);
+
+    function transfer(uint256 nftId, address newOwner) external;
+
+    function getNftId(address objectAddress) external view returns(uint256 nftId);
+    function getInfo(uint256 nftId) external view returns(RegistryInfo memory info);
+    function getOwner(uint256 nftId) external view returns(address ownerAddress);
+
+    function isRegistered(address objectAddress) external view returns(bool);
+}

package/contracts/registry/Registry.sol

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry, IRegistryLinked, IRegisterable} from "./IRegistry.sol";
+
+contract RegistryLinked is IRegistryLinked {
+
+    IRegistry internal _registry;
+    
+    constructor(address registry) {
+        _registry = IRegistry(registry);
+    }
+
+    // function setRegistry(address registry) public override {
+    //     require(address(_registry) == address(0), "ERROR:RGL-001:REGISTRY_ALREADY_SET");
+    //     _registry = IRegistry(registry);
+    // }
+
+    function getRegistry() external view override returns(IRegistry registry) {
+        return _registry;
+    }
+
+}
+
+
+abstract contract Registerable is 
+    RegistryLinked,
+    IRegisterable
+{
+
+    address private _initialOwner;
+    
+    constructor(address registry)
+        RegistryLinked(registry)
+    {
+        _initialOwner = msg.sender;
+    }
+
+    // getType, getData and register need to be implemented by concrete contract
+
+    function isRegisterable() external pure override returns(bool) {
+        return true;
+    }
+
+    function getInitialOwner() public view override returns(address deployer) {
+        return _initialOwner;
+    }
+
+    function isRegistered() public view override returns(bool) {
+        return _registry.getNftId(address(this)) > 0;
+    }
+
+    function getNftId() public view override returns(uint256 id) {
+        return _registry.getNftId(address(this));
+    }
+
+    function getOwner() public view override returns(address owner) {
+        uint256 id = _registry.getNftId(address(this));
+        owner = _registry.getOwner(id);
+        return owner != address(0) ? owner : _initialOwner;
+    }
+
+}
+
+    // struct RegistryInfo {
+    //     bytes32 id;
+    //     uint256 objectType;
+    //     address objectAddress;
+    //     address initialOwner;
+    // }
+
+contract Registry is IRegistry {
+
+    mapping(uint256 id => RegistryInfo info) private _info;
+    mapping(uint256 id => address owner) private _owner;
+    mapping(address object => uint256 id) private _idByAddress;
+    uint256 [] private _ids;
+    uint256 private _idNext;
+
+
+    constructor() {
+        _idNext = 0;
+    }
+
+    function TOKEN() public pure override returns(uint256) { return 30; }
+    function INSTANCE() public pure override returns(uint256) { return 40; }
+    function PRODUCT() public pure override returns(uint256) { return 50; }
+    function ORACLE() public pure override returns(uint256) { return 60; }
+    function POOL() public pure override returns(uint256) { return 70; }
+    function POLICY() public pure override returns(uint256) { return 80; }
+    function BUNDLE() public pure override returns(uint256) { return 90; }
+
+    function register(address objectAddress) external override returns(uint256 nftId) {
+        require(_idByAddress[objectAddress] == 0, "ERROR:REG-001:ALREADY_REGISTERED");
+
+        IRegisterable registerable = IRegisterable(objectAddress);
+        require(registerable.isRegisterable(), "ERROR:REG-002:NOT_REGISTERABLE");
+
+        // check parent exists (for objects not instances)
+        if(registerable.getType() != INSTANCE()) {
+            RegistryInfo memory parentInfo = _info[registerable.getParentNftId()];
+            require(parentInfo.nftId > 0, "ERROR:REG-003:PARENT_NOT_FOUND");
+            // check validity of parent relation, valid relations are
+            // policy -> product, bundle -> pool, product -> instance, pool -> instance
+        }
+
+        nftId = _mint(registerable.getInitialOwner());
+    
+        RegistryInfo memory info = RegistryInfo(
+            nftId,
+            registerable.getParentNftId(),
+            registerable.getType(),
+            objectAddress,
+            registerable.getInitialOwner()
+        );
+
+        _info[nftId] = info;
+        _idByAddress[objectAddress] = nftId;
+
+        // add logging
+    }
+
+
+    function registerObjectForInstance(
+        uint256 parentNftId,
+        uint256 objectType,
+        address initialOwner
+    )
+        external 
+        override
+        // TODO add onlyRegisteredInstance
+        returns(uint256 nftId)
+    {
+        // TODO add more validation
+        require(
+            objectType == POLICY() || objectType == BUNDLE(),
+            "ERROR:REG-005:TYPE_INVALID");
+
+        nftId = _mint(initialOwner);
+
+        RegistryInfo memory info = RegistryInfo(
+            nftId,
+            parentNftId,
+            objectType,
+            address(0),
+            initialOwner
+        );
+
+        _info[nftId] = info;
+
+        // add logging
+    }
+
+
+    function transfer(uint256 id, address newOwner) external {
+        require(msg.sender == _owner[id], "ERROR:REG-010:NOT_OWNER");
+        _owner[id] = newOwner;
+
+        // TODO logging
+    }
+
+
+    function getObjectCount() external view returns(uint256) {
+        return _ids.length;
+    }
+
+
+    function getNftId(address object) external view override returns(uint256 id) {
+        return _idByAddress[object];
+    }
+
+
+    function isRegistered(address object) external view override returns(bool) {
+        return _idByAddress[object] > 0;
+    }
+
+
+    function getInfo(uint256 id) external view override returns(RegistryInfo memory info) {
+        return _info[id];
+    }
+
+    function getOwner(uint256 id) external view override returns(address) {
+        return _owner[id];
+    }
+
+
+    function _mint(address initialOwner)
+        internal
+        returns(uint256 id)
+    {
+        _idNext++;
+
+        id = _idNext;
+        _owner[id] = initialOwner;
+        _ids.push(id);
+    }
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-ebbe63d",
+  "version": "0.0.2-fe77319",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {
-    "build": "hardhat compile",
-    "test": "hardhat test",
-    "ptest": "hardhat test --parallel",
-    "test-with-gas": "REPORT_GAS=true hardhat test",
-    "coverage": "hardhat coverage"
+    "build": "hh compile",
+    "test": "hh test",
+    "ptest": "hh test --parallel",
+    "test-with-gas": "REPORT_GAS=true hh test",
+    "coverage": "hh coverage"
   },
   "repository": {
     "type": "git",
@@ -27,6 +27,7 @@
   "devDependencies": {
     "@nomicfoundation/hardhat-foundry": "^1.0.3",
     "@nomicfoundation/hardhat-toolbox": "^3.0.0",
+    "dotenv": "^16.3.1",
     "hardhat": "^2.17.1"
   },
   "dependencies": {

package/artifacts/contracts/Dip.sol/DIP.dbg.json

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