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

package/contracts/experiment/inheritance/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/inheritance/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 newB) external override { _x = newB; }
+
+    // access state from parent contract A
+    function getAfromB() external view override returns(uint256) { return this.getA(); }
+
+}

package/contracts/experiment/inheritance/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 newC) external override { _x = newC; }
+
+    // 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/inheritance/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/inheritance/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/inheritance/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/experiment/types/TypeA.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+/*
+# chisel session for user defined types
+
+import {TypeA, toTypeA} from "./contracts/experiment/types/TypeA.sol";
+TypeA a = toTypeA(1);
+TypeA b = toTypeA(2);
+uint(a.toInt())
+uint(b.toInt())
+a == b
+a != b
+
+import {TypeB, toTypeB} from "./contracts/experiment/types/TypeB.sol";
+TypeB x = toTypeB(33);
+uint(x.toInt())
+a == x; // -> error
+a.toInt() == x.toInt() // -> no error
+ */
+
+// bytes5 allows for chain ids up to 13 digits
+type TypeA is uint248;
+
+// type bindings
+using {
+    eqTypeA as ==,
+    neTypeA as !=,
+    TypeALib.toInt
+} for TypeA global;
+
+// general pure free functions
+function toTypeA(uint256 typeA) pure returns(TypeA) { return TypeA.wrap(uint248(typeA)); }
+
+// pure free functions for operators
+function eqTypeA(TypeA a, TypeA b) pure returns(bool isSame) { return TypeA.unwrap(a) == TypeA.unwrap(b); }
+function neTypeA(TypeA a, TypeA b) pure returns(bool isDifferent) { return TypeA.unwrap(a) != TypeA.unwrap(b); }
+
+// library functions that operate on user defined type
+library TypeALib {
+    function toInt(TypeA typeA) internal pure returns(uint256) { return uint256(TypeA.unwrap(typeA)); }
+}

package/contracts/experiment/types/TypeB.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// bytes5 allows for chain ids up to 13 digits
+type TypeB is uint248;
+
+// type bindings
+using {
+    eqTypeB as ==,
+    addTypeB as +,
+    TypeBLib.toInt
+} for TypeB global;
+
+// general pure free functions
+function toTypeB(uint256 x) pure returns(TypeB) { return TypeB.wrap(uint248(x)); }
+
+// pure free functions for operators
+function eqTypeB(TypeB a, TypeB b) pure returns(bool isSame) { return TypeB.unwrap(a) == TypeB.unwrap(b); }
+function addTypeB(TypeB a, TypeB b) pure returns(TypeB sum) { return TypeB.wrap(TypeB.unwrap(a) + TypeB.unwrap(b)); }
+
+// library functions that operate on user defined type
+library TypeBLib {
+    function toInt(TypeB b) internal pure returns(uint256) { return uint256(TypeB.unwrap(b)); }
+}

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,
+    IPolicyModule,
+    IPoolModule,
+    IComponentModule,
+    IProductModule
+{ }
+

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);
+}