@etherisc/gif-next 0.0.2-34d25ca → 0.0.2-35bac6a

package/contracts/experiment/types/TypeB.sol

@@ -5,25 +5,20 @@ pragma solidity ^0.8.19;
 type TypeB is uint248;
 
 // type bindings
-using {eqTypeB as ==, addTypeB as +, TypeBLib.toInt} for TypeB global;
+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));
-}
+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));
-}
+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));
-    }
+    function toInt(TypeB b) internal pure returns(uint256) { return uint256(TypeB.unwrap(b)); }
 }

package/contracts/instance/IInstance.sol

@@ -8,6 +8,7 @@ import {IProductModule} from "./product/IProductService.sol";
 import {IPolicyModule} from "./policy/IPolicy.sol";
 import {IPoolModule} from "./pool/IPoolModule.sol";
 
+
 interface IInstance is
     IRegisterable,
     IAccessModule,
@@ -15,4 +16,5 @@ interface IInstance is
     IPoolModule,
     IComponentModule,
     IProductModule
-{}
+{ }
+

package/contracts/instance/Instance.sol

@@ -16,12 +16,13 @@ import {NftId, toNftId} from "../types/NftId.sol";
 contract Instance is
     Registerable,
     AccessModule,
-    ComponentModule,
-    PolicyModule,
+    ComponentModule, 
+    PolicyModule, 
     PoolModule,
-    ProductModule,
+    ProductModule, 
     IInstance
 {
+
     constructor(
         address registry,
         address componentOwnerService,
@@ -33,32 +34,31 @@ contract Instance is
         PolicyModule(productService)
         ProductModule(productService)
         PoolModule(productService)
-    {}
+    { }
 
     // from registerable
-    function register() external override returns (NftId nftId) {
-        require(
-            address(_registry) != address(0),
-            "ERROR:PRD-001:REGISTRY_ZERO"
-        );
+    function register() external override returns(NftId nftId) {
+        require(address(_registry) != address(0), "ERROR:PRD-001:REGISTRY_ZERO");
         return _registry.register(address(this));
     }
 
     // from registerable
-    function getParentNftId() public view override returns (NftId) {
+    function getParentNftId() public view override returns(NftId) {
         // 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
+        // eg 0 <- chain(mainnet) <- global registry <- chain registry <- instance <- component <- policy/bundle 
         return toNftId(0);
     }
 
     // from registerable
-    function getType() external view override returns (uint256 objectType) {
+    function getType() external view override returns(uint256 objectType) {
         return _registry.INSTANCE();
     }
 
     // from registerable
-    function getData() external view override returns (bytes memory data) {
+    function getData() external view override returns(bytes memory data) {
         return bytes(abi.encode(0));
     }
+
+
 }

package/contracts/instance/access/Access.sol

@@ -7,24 +7,26 @@ import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 import {IAccessModule} from "./IAccess.sol";
 
-abstract contract AccessModule is IAccessModule {
-    string public constant PRODUCT_OWNER = "ProductOwner";
-    string public constant ORACLE_OWNER = "OracleOwner";
-    string public constant POOL_OWNER = "PoolOwner";
+
+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 _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 => mapping(address member => bool isMember)) private _isRoleMember;
     mapping(bytes32 role => EnumerableSet.AddressSet) private _roleMembers;
 
     modifier onlyOwner() {
@@ -38,54 +40,70 @@ abstract contract AccessModule is IAccessModule {
         _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 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 POOL_OWNER_ROLE() public view override returns (bytes32 role) {
-        return _poolOwnerRole;
-    }
 
-    function createRole(
-        string memory roleName
-    ) external override onlyOwner returns (bytes32 role) {
+    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);
+    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 {
+    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 {
+    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 {
+        
+    }   
+
+    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");
 
@@ -95,71 +113,106 @@ abstract contract AccessModule is IAccessModule {
         emit LogAccessRoleGranted(role, member, _isRoleMember[role][member]);
     }
 
-    function revokeRole(
-        bytes32 role,
-        address member
-    ) external override onlyOwner {
+
+    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) {
+
+    function hasRole(bytes32 role, address member)
+        external
+        view
+        override
+        returns(bool)
+    {
         return _isRoleMember[role][member];
     }
 
-    function getRoleInfo(
-        bytes32 role
-    ) external view override returns (RoleInfo memory info) {
+
+    function getRoleInfo(bytes32 role)
+        external
+        override
+        view
+        returns(RoleInfo memory info)
+    {
         return _info[role];
     }
 
-    function getRole(
-        uint256 idx
-    ) external view override returns (bytes32 role) {
+
+    function getRole(uint256 idx)
+        external
+        override
+        view
+        returns(bytes32 role)
+    {
         return _roles[idx];
     }
 
-    function getRoleCount() external view override returns (uint256 roles) {
-        return _roles.length;
-    }
 
-    function getRoleMemberCount(
-        bytes32 role
-    ) public view override returns (uint256 roleMembers) {
+    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 view override returns (address roleMembers) {
+    function getRoleMember(bytes32 role, uint256 idx)
+        public
+        override
+        view
+        returns(address roleMembers)
+    {
         return _roleMembers[role].at(idx);
     }
 
-    function getRoleForName(
-        string memory roleName
-    ) public pure override returns (bytes32 role) {
+    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) {
+
+    function _setRoleInfo(RoleInfo memory info)
+        internal
+        returns(bytes32 role)
+    {
         role = info.id;
 
-        if (role == bytes32(0)) {
+        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

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