@etherisc/gif-next 0.0.2-d250c72 → 0.0.2-d3543ee-345

package/contracts/experiment/types/TypeB.sol

@@ -5,20 +5,25 @@ 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

@@ -3,18 +3,23 @@ pragma solidity ^0.8.19;
 
 import {IRegisterable} from "../registry/IRegistry.sol";
 import {IAccessModule} from "./access/IAccess.sol";
+import {ILifecycleModule} from "./lifecycle/ILifecycle.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";
+import {ITreasuryModule} from "./treasury/ITreasury.sol";
 
-
+// solhint-disable-next-line no-empty-blocks
 interface IInstance is
     IRegisterable,
     IAccessModule,
+    ILifecycleModule,
     IPolicyModule,
     IPoolModule,
     IComponentModule,
-    IProductModule
-{ }
+    IProductModule,
+    ITreasuryModule
+{
 
+}

package/contracts/instance/Instance.sol

@@ -5,24 +5,28 @@ import {Registerable} from "../registry/Registry.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 
 import {IAccessModule, AccessModule} from "./access/Access.sol";
+import {LifecycleModule} from "./lifecycle/LifecycleModule.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 {TreasuryModule} from "./treasury/TreasuryModule.sol";
 
 import {IInstance} from "./IInstance.sol";
+import {ObjectType, INSTANCE} from "../types/ObjectType.sol";
 import {NftId, toNftId} from "../types/NftId.sol";
 
 contract Instance is
     Registerable,
     AccessModule,
-    ComponentModule, 
-    PolicyModule, 
+    LifecycleModule,
+    ComponentModule,
+    PolicyModule,
     PoolModule,
-    ProductModule, 
+    ProductModule,
+    TreasuryModule,
     IInstance
 {
-
     constructor(
         address registry,
         address componentOwnerService,
@@ -34,31 +38,35 @@ contract Instance is
         PolicyModule(productService)
         ProductModule(productService)
         PoolModule(productService)
-    { }
+    // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
 
     // 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 pure 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) {
-        return _registry.INSTANCE();
+    function getType() external pure override returns (ObjectType objectType) {
+        return INSTANCE();
     }
 
     // from registerable
-    function getData() external view override returns(bytes memory data) {
+    function getData() external pure override returns (bytes memory data) {
         return bytes(abi.encode(0));
     }
-
-
 }

package/contracts/instance/access/Access.sol

@@ -7,26 +7,24 @@ 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";
+abstract contract AccessModule is IAccessModule {
+    string public constant PRODUCT_OWNER = "ProductOwner";
+    string public constant ORACLE_OWNER = "OracleOwner";
+    string public constant 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() {
@@ -40,70 +38,54 @@ abstract contract AccessModule is
         _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 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)
-    {
+    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");
 
@@ -113,106 +95,71 @@ abstract contract AccessModule is
         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
-        override
-        view
-        returns(RoleInfo memory info)
-    {
+    function getRoleInfo(
+        bytes32 role
+    ) external view override returns (RoleInfo memory info) {
         return _info[role];
     }
 
-
-    function getRole(uint256 idx)
-        external
-        override
-        view
-        returns(bytes32 role)
-    {
+    function getRole(
+        uint256 idx
+    ) external view override returns (bytes32 role) {
         return _roles[idx];
     }
 
-
-    function getRoleCount()
-        external
-        override
-        view
-        returns(uint256 roles)
-    {
+    function getRoleCount() external view override returns (uint256 roles) {
         return _roles.length;
-    }        
-
-    function getRoleMemberCount(bytes32 role)
-        public
-        override
-        view
-        returns(uint256 roleMembers)
-    {
+    }
+
+    function getRoleMemberCount(
+        bytes32 role
+    ) public view override returns (uint256 roleMembers) {
         return _roleMembers[role].length();
     }
 
-    function getRoleMember(bytes32 role, uint256 idx)
-        public
-        override
-        view
-        returns(address roleMembers)
-    {
+    function getRoleMember(
+        bytes32 role,
+        uint256 idx
+    ) public view override returns (address roleMembers) {
         return _roleMembers[role].at(idx);
     }
 
-    function getRoleForName(string memory roleName)
-        public
-        override
-        pure
-        returns(bytes32 role)
-    {
+    function getRoleForName(
+        string memory roleName
+    ) public pure override 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,7 +4,6 @@ pragma solidity ^0.8.19;
 import {IOwnable, IRegistryLinked} from "../../registry/IRegistry.sol";
 
 interface IAccess {
-
     struct RoleInfo {
         bytes32 id;
         string name;
@@ -13,71 +12,52 @@ 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);
 
-interface IAccessModule is 
+    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 createRole(string memory roleName)
-        external
-        returns(bytes32 role);
-
-    function enableRole(bytes32 role)
-        external;       
+    function enableRole(bytes32 role) external;
 
-    function disableRole(bytes32 role)
-        external;       
+    function disableRole(bytes32 role) external;
 
-    function grantRole(bytes32 role, address member)
-        external;       
+    function grantRole(bytes32 role, address member) external;
 
-    function revokeRole(bytes32 role, address member)
-        external;       
+    function revokeRole(bytes32 role, address member) external;
 
-    function getRole(uint256 idx)
-        external
-        view
-        returns(bytes32 role);
+    function getRole(uint256 idx) external view returns (bytes32 role);
 
-    function getRoleInfo(bytes32 role)
-        external
-        view
-        returns(RoleInfo memory info);
+    function getRoleInfo(
+        bytes32 role
+    ) external view returns (RoleInfo memory info);
 
-    function getRoleForName(string memory roleName)
-        external
-        pure
-        returns(bytes32 role);
+    function getRoleForName(
+        string memory roleName
+    ) external pure returns (bytes32 role);
 
-    function getRoleCount()
-        external
-        view
-        returns(uint256 roles);
+    function getRoleCount() external view returns (uint256 roles);
 
-    function getRoleMemberCount(bytes32 role)
-        external
-        view
-        returns(uint256 roleMembers);
+    function getRoleMemberCount(
+        bytes32 role
+    ) external view returns (uint256 roleMembers);
 
-    function getRoleMember(bytes32 role, uint256 idx)
-        external
-        view
-        returns(address roleMembers);
-}
+    function getRoleMember(
+        bytes32 role,
+        uint256 idx
+    ) external view returns (address roleMembers);
+}