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

package/contracts/components/IPool.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponentContract} from "../instance/component/IComponent.sol";
+
+// just marker interface for now
+interface IPoolComponent is
+    IComponentContract
+{ }

package/contracts/components/IProduct.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponentContract} from "../instance/component/IComponent.sol";
+
+interface IProductComponent is
+    IComponentContract
+{
+
+    function getPoolNftId() external view returns(uint256 poolNftId);
+}

package/contracts/components/Pool.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IPoolComponent} from "./IPool.sol";
+import {Component} from "./Component.sol";
+
+
+contract Pool is
+    Component,
+    IPoolComponent
+{
+
+    constructor(
+        address registry, 
+        address instance
+    )
+        Component(registry, instance)
+    { }
+
+    // from registerable
+    function getType() public view override returns(uint256) {
+        return _registry.POOL();
+    }
+
+    // from registerable
+    function getData() external view override returns(bytes memory data) {
+        return bytes(abi.encode(getInstance().getNftId()));
+    }
+}

package/contracts/components/Product.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IProductService} from "../instance/product/IProductService.sol";
+import {Component} from "./Component.sol";
+import {IProductComponent} from "./IProduct.sol";
+
+
+contract Product is
+    Component,
+    IProductComponent
+{
+    IProductService private _productService;
+    address private _pool;
+
+    constructor(
+        address registry, 
+        address instance, 
+        address pool
+    )
+        Component(registry, instance)
+    { 
+        _productService = _instance.getProductService();
+        _pool = pool;
+    }
+
+    function _createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        uint256 bundleNftId
+    )
+        internal
+        returns(uint256 nftId)
+    {
+        nftId = _productService.createApplication(
+            applicationOwner,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId
+        );
+    }
+
+    function _underwrite(uint256 nftId)
+        internal
+    {
+        _productService.underwrite(nftId);
+    }
+
+    function getPoolNftId() external view override returns(uint256 poolNftId) {
+        return _registry.getNftId(_pool);
+    }
+
+    // from registerable
+    function getType() public view override returns(uint256) {
+        return _registry.PRODUCT();
+    }
+
+    // from registerable
+    function getData() external view override returns(bytes memory data) {
+        return bytes(abi.encode(getInstance().getNftId()));
+    }
+}

package/contracts/experiment/A.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IA, ISharedA} from "./IA.sol";
+import {B} from "./B.sol";
+import {C} from "./C.sol";
+
+/* 
+
+# dependency graph
+
+   B <...+
+   ^     |
+   |     |
+   A --> C
+
+   - A is the main contract
+   - A provides functionality implemented by modules B and C
+   - B and C rely on functionality shared by A
+   - C accesses functionality of module B
+
+# chisel session
+
+import {A} from "./contracts/experiment/A.sol";
+A a = new A();
+uint(a.getA())
+uint(a.getB()))
+uint(a.getC())
+uint(a.getAfromB())
+uint(a.getAfromC())
+uint(a.getBfromC())
+a.setA(100);
+a.setB(10);
+a.setC(20);
+ */
+
+contract AShared is ISharedA {
+
+    uint256 private _x;
+
+    constructor() {
+        _x = 42;
+    }
+
+    function getA() external view override returns(uint256) { return _x; }
+    function setA(uint256 newA) external override { _x = newA; }
+}
+
+contract A is
+    AShared,
+    B,
+    C,
+    IA
+{
+
+}

package/contracts/experiment/B.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ISharedA} from "./IA.sol";
+import {IB} from "./IB.sol";
+
+abstract contract B is ISharedA, IB {
+
+    // names of private variables can be re-used in inheritance
+    uint256 private _x;
+
+    constructor() {
+        _x = 1;
+    }
+
+    // access own state
+    function getB() external view override returns(uint256) { return _x; }
+    function setB(uint256 newA) external override { _x = newA; }
+
+    // access state from parent contract A
+    function getAfromB() external view override returns(uint256) { return this.getA(); }
+
+}

package/contracts/experiment/C.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ISharedA} from "./IA.sol";
+import {IB} from "./IB.sol";
+import {IC} from "./IC.sol";
+
+abstract contract C is ISharedA, IC {
+
+    uint256 private _x;
+
+    constructor() {
+        _x = 2;
+    }
+
+    // access own state
+    function getC() external view override returns(uint256) { return _x; }
+    function setC(uint256 newA) external override { _x = newA; }
+
+    // access state from parent contract A
+    function getAfromC() external view override returns(uint256) { return this.getA(); }
+
+    // access state from other module B
+    function getBfromC() external view override returns(uint256) {
+        IB b = IB(address(this));
+        return b.getB();
+    }
+}

package/contracts/experiment/IA.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IB} from "./IB.sol";
+import {IC} from "./IC.sol";
+
+interface ISharedA {
+
+    function getA() external view returns(uint256);
+    function setA(uint256 newA) external;
+}
+
+interface IA is
+    ISharedA,
+    IB,
+    IC
+{
+}

package/contracts/experiment/IB.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+interface IB {
+
+    function getAfromB() external view returns(uint256);
+    function getB() external view returns(uint256);
+    function setB(uint256 newA) external;
+}

package/contracts/experiment/IC.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+interface IC {
+
+    function getAfromC() external view returns(uint256);
+    function getBfromC() external view returns(uint256);
+
+    function getC() external view returns(uint256);
+    function setC(uint256 newA) external;
+}

package/contracts/instance/IInstance.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegisterable} from "../registry/IRegistry.sol";
+import {IAccessModule} from "./access/IAccess.sol";
+import {IComponentModule} from "./component/IComponent.sol";
+import {IProductModule} from "./product/IProductService.sol";
+import {IPolicyModule} from "./policy/IPolicy.sol";
+import {IPoolModule} from "./pool/IPoolModule.sol";
+
+
+interface IInstance is
+    IRegisterable,
+    IAccessModule,
+    IComponentModule,
+    IProductModule,
+    IPolicyModule,
+    IPoolModule
+{ }
+

package/contracts/instance/Instance.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Registerable} from "../registry/Registry.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+
+import {IAccessModule, AccessModule} from "./access/Access.sol";
+import {ComponentModule} from "./component/ComponentModule.sol";
+import {ProductModule} from "./product/ProductService.sol";
+import {PolicyModule} from "./policy/PolicyModule.sol";
+import {PoolModule} from "./pool/PoolModule.sol";
+
+import {IInstance} from "./IInstance.sol";
+
+contract Instance is
+    Registerable,
+    AccessModule,
+    ComponentModule, 
+    PolicyModule, 
+    PoolModule,
+    ProductModule, 
+    IInstance
+{
+
+    constructor(
+        address registry,
+        address componentOwnerService,
+        address productService
+    )
+        Registerable(registry)
+        AccessModule()
+        ComponentModule(componentOwnerService)
+        PolicyModule(productService)
+        ProductModule(productService)
+        PoolModule(productService)
+    { }
+
+    // from registerable
+    function register() external override returns(uint256 id) {
+        require(address(_registry) != address(0), "ERROR:PRD-001:REGISTRY_ZERO");
+        return _registry.register(address(this));
+    }
+
+    // from registerable
+    function getParentNftId() public view override returns(uint256) {
+        // TODO  add self registry and exchange 0 for_registry.getNftId();
+        // define parent tree for all registerables
+        // eg 0 <- chain(mainnet) <- global registry <- chain registry <- instance <- component <- policy/bundle 
+        return 0;
+    }
+
+    // from registerable
+    function getType() external view override returns(uint256 objectType) {
+        return _registry.INSTANCE();
+    }
+
+    // from registerable
+    function getData() external view override returns(bytes memory data) {
+        return bytes(abi.encode(0));
+    }
+
+
+}

package/contracts/instance/access/Access.sol

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// role admin handling of oz doesn't fit nft ownability
+// import {AccessControlEnumerable} from "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import {IAccessModule} from "./IAccess.sol";
+
+
+abstract contract AccessModule is
+    IAccessModule
+{
+    string constant public PRODUCT_OWNER = "ProductOwner";
+    string constant public ORACLE_OWNER = "OracleOwner";
+    string constant public POOL_OWNER = "PoolOwner";
+
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    event LogAccessRoleGranted(bytes32 role, address member, bool isMember);
+
+    mapping(bytes32 role => RoleInfo info) private _info;
+    bytes32 [] private _roles;
+
+    bytes32 private immutable _productOwnerRole;
+    bytes32 private immutable _oracleOwnerRole;
+    bytes32 private immutable _poolOwnerRole;
+
+    mapping(bytes32 role => mapping(address member => bool isMember)) private _isRoleMember;
+    mapping(bytes32 role => EnumerableSet.AddressSet) private _roleMembers;
+
+    modifier onlyOwner() {
+        require(msg.sender == this.getOwner(), "ERROR:ACM-001:NOT_OWNER");
+        _;
+    }
+
+    constructor() {
+        _productOwnerRole = _createRole(PRODUCT_OWNER);
+        _oracleOwnerRole = _createRole(ORACLE_OWNER);
+        _poolOwnerRole = _createRole(POOL_OWNER);
+    }
+
+    function PRODUCT_OWNER_ROLE() public view override returns(bytes32 role) { return _productOwnerRole; }
+    function ORACLE_OWNER_ROLE() public view override returns(bytes32 role) { return _oracleOwnerRole; }
+    function POOL_OWNER_ROLE() public view override returns(bytes32 role) { return _poolOwnerRole; }
+
+
+    function createRole(string memory roleName) 
+        external
+        override
+        onlyOwner
+        returns(bytes32 role)
+    {
+        return _createRole(roleName);
+    }
+
+    function _createRole(string memory roleName) 
+        internal
+        returns(bytes32 role)
+    {
+        RoleInfo memory info = RoleInfo(
+            0,
+            roleName,
+            true
+        );
+
+        role = _setRoleInfo(info);
+
+        
+    }
+
+    // TODO move to module
+    function disableRole(bytes32 role) 
+        external
+        override
+        onlyOwner
+    {
+        RoleInfo memory info = _info[role];
+        require(info.id == role, "ERROR:AOS-001:ROLE_DOES_NOT_EXIST");
+
+        info.isActive = false;
+        _setRoleInfo(info);
+
+        
+    }   
+
+    // TODO move to module
+    function enableRole(bytes32 role) 
+        external
+        override       
+        onlyOwner
+    {
+        RoleInfo memory info = _info[role];
+        require(info.id == role, "ERROR:AOS-002:ROLE_DOES_NOT_EXIST");
+
+        info.isActive = true;
+        _setRoleInfo(info);
+
+        
+    }   
+
+    function grantRole(bytes32 role, address member) 
+        external
+        override     
+        onlyOwner
+    {
+        require(_info[role].id == role, "ERROR:ACM-010:ROLE_NOT_EXISTING");
+        require(_info[role].isActive, "ERROR:ACM-011:ROLE_NOT_ACTIVE");
+
+        _isRoleMember[role][member] = true;
+        _roleMembers[role].add(member);
+
+        emit LogAccessRoleGranted(role, member, _isRoleMember[role][member]);
+    }
+
+
+    function revokeRole(bytes32 role, address member) 
+        external
+        override     
+        onlyOwner
+    {
+        require(_info[role].id == role, "ERROR:ACM-020:ROLE_NOT_EXISTING");
+
+        _isRoleMember[role][member] = false;
+        _roleMembers[role].remove(member);
+
+        
+    }
+
+
+    function hasRole(bytes32 role, address member)
+        external
+        view
+        override
+        returns(bool)
+    {
+        return _isRoleMember[role][member];
+    }
+
+
+    function getRoleInfo(bytes32 role)
+        external
+        override
+        view
+        returns(RoleInfo memory info)
+    {
+        return _info[role];
+    }
+
+
+    function getRole(uint256 idx)
+        external
+        override
+        view
+        returns(bytes32 role)
+    {
+        return _roles[idx];
+    }
+
+
+    function getRoleCount()
+        external
+        override
+        view
+        returns(uint256 roles)
+    {
+        return _roles.length;
+    }        
+
+    function getRoleMemberCount(bytes32 role)
+        public
+        override
+        view
+        returns(uint256 roleMembers)
+    {
+        return _roleMembers[role].length();
+    }
+
+    function getRoleMember(bytes32 role, uint256 idx)
+        public
+        override
+        view
+        returns(address roleMembers)
+    {
+        return _roleMembers[role].at(idx);
+    }
+
+    function getRoleForName(string memory roleName)
+        public
+        override
+        pure
+        returns(bytes32 role)
+    {
+        return keccak256(abi.encode(roleName));
+    }
+
+
+    function _setRoleInfo(RoleInfo memory info)
+        internal
+        returns(bytes32 role)
+    {
+        role = info.id;
+
+        if(role == bytes32(0)) {
+            role = getRoleForName(info.name);
+            // TODO check that this is a new role id
+
+            info.id = role;
+            _roles.push(role);
+
+            
+        }
+
+        _info[role] = info;
+
+        
+    }
+}

package/contracts/instance/access/IAccess.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IOwnable, IRegistryLinked} from "../../registry/IRegistry.sol";
+
+interface IAccess {
+
+    struct RoleInfo {
+        bytes32 id;
+        string name;
+        bool isActive;
+    }
+}
+
+interface IAccessCheckRole {
+
+    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);
+}
+
+
+interface IAccessModule is 
+    IOwnable,
+    IRegistryLinked,
+    IAccess,
+    IAccessComponentTypeRoles,
+    IAccessCheckRole
+{
+
+    function createRole(string memory roleName)
+        external
+        returns(bytes32 role);
+
+    function enableRole(bytes32 role)
+        external;       
+
+    function disableRole(bytes32 role)
+        external;       
+
+    function grantRole(bytes32 role, address member)
+        external;       
+
+    function revokeRole(bytes32 role, address member)
+        external;       
+
+    function getRole(uint256 idx)
+        external
+        view
+        returns(bytes32 role);
+
+    function getRoleInfo(bytes32 role)
+        external
+        view
+        returns(RoleInfo memory info);
+
+    function getRoleForName(string memory roleName)
+        external
+        pure
+        returns(bytes32 role);
+
+    function getRoleCount()
+        external
+        view
+        returns(uint256 roles);
+
+    function getRoleMemberCount(bytes32 role)
+        external
+        view
+        returns(uint256 roleMembers);
+
+    function getRoleMember(bytes32 role, uint256 idx)
+        external
+        view
+        returns(address roleMembers);
+}