@etherisc/gif-next 0.0.2-ebbe63d → 0.0.2-f619be3-760

package/contracts/instance/Instance.sol

@@ -0,0 +1,72 @@
+// 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 {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,
+    LifecycleModule,
+    ComponentModule,
+    PolicyModule,
+    PoolModule,
+    ProductModule,
+    TreasuryModule,
+    IInstance
+{
+    constructor(
+        address registry,
+        address componentOwnerService,
+        address productService
+    )
+        Registerable(registry)
+        AccessModule()
+        ComponentModule(componentOwnerService)
+        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"
+        );
+        return _registry.register(address(this));
+    }
+
+    // from registerable
+    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
+        return toNftId(0);
+    }
+
+    // from registerable
+    function getType() external pure override returns (ObjectType objectType) {
+        return INSTANCE();
+    }
+
+    // from registerable
+    function getData() external pure override returns (bytes memory data) {
+        return bytes(abi.encode(0));
+    }
+}

package/contracts/instance/access/Access.sol

@@ -0,0 +1,165 @@
+// 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 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 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 view override returns (RoleInfo memory info) {
+        return _info[role];
+    }
+
+    function getRole(
+        uint256 idx
+    ) external view override 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) {
+        return _roleMembers[role].length();
+    }
+
+    function getRoleMember(
+        bytes32 role,
+        uint256 idx
+    ) public view override returns (address roleMembers) {
+        return _roleMembers[role].at(idx);
+    }
+
+    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) {
+        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,63 @@
+// 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);
+}

package/contracts/instance/component/ComponentModule.sol

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {RegistryLinked} from "../../registry/Registry.sol";
+import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+import {IAccessComponentTypeRoles, IAccessCheckRole} from "../access/IAccess.sol";
+import {IInstance} from "../IInstance.sol";
+
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
+import {ITreasuryModule} from "../treasury/ITreasury.sol";
+import {TreasuryModule} from "../treasury/TreasuryModule.sol";
+import {IComponent, IComponentContract, IComponentModule, IComponentOwnerService} from "./IComponent.sol";
+import {IProductComponent} from "../../components/IProduct.sol";
+import {IPoolComponent} from "../../components/IPool.sol";
+import {IPoolModule} from "../pool/IPoolModule.sol";
+import {ObjectType, PRODUCT, ORACLE, POOL} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED} from "../../types/StateId.sol";
+import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
+import {Fee, zeroFee} from "../../types/Fee.sol";
+
+abstract contract ComponentModule is
+    IRegistryLinked,
+    IAccessComponentTypeRoles,
+    IAccessCheckRole,
+    IComponentModule
+{
+    using NftIdLib for NftId;
+
+    mapping(NftId nftId => ComponentInfo info) private _componentInfo;
+    mapping(address cAddress => NftId nftId) private _nftIdByAddress;
+    NftId[] private _nftIds;
+
+    mapping(ObjectType cType => bytes32 role) private _componentOwnerRole;
+
+    // TODO maybe move this to Instance contract as internal variable?
+    LifecycleModule private _lifecycleModule;
+    TreasuryModule private _treasuryModule;
+    IPoolModule private _poolModule;
+    IComponentOwnerService private _componentOwnerService;
+
+    modifier onlyComponentOwnerService() {
+        require(
+            address(_componentOwnerService) == msg.sender,
+            "ERROR:CMP-001:NOT_OWNER_SERVICE"
+        );
+        _;
+    }
+
+    constructor(address componentOwnerService) {
+        address componentAddress = address(this);
+        _lifecycleModule = LifecycleModule(componentAddress);
+        _treasuryModule = TreasuryModule(componentAddress);
+        _poolModule = IPoolModule(componentAddress);
+        _componentOwnerService = ComponentOwnerService(componentOwnerService);
+    }
+
+    function registerComponent(
+        IComponentContract component
+    ) external override onlyComponentOwnerService returns (NftId nftId) {
+        ObjectType objectType = component.getType();
+        bytes32 typeRole = getRoleForType(objectType);
+        require(
+            this.hasRole(typeRole, component.getInitialOwner()),
+            "ERROR:CMP-004:TYPE_ROLE_MISSING"
+        );
+
+        nftId = this.getRegistry().register(address(component));
+        IERC20Metadata token = component.getToken();
+        address wallet = component.getWallet();
+
+        // create component info
+        _componentInfo[nftId] = ComponentInfo(
+            nftId,
+            _lifecycleModule.getInitialState(objectType),
+            token
+        );
+
+        // component type specific registration actions
+        if (component.getType() == PRODUCT()) {
+            IProductComponent product = IProductComponent(address(component));
+            NftId poolNftId = product.getPoolNftId();
+            require(poolNftId.gtz(), "ERROR:CMP-005:POOL_UNKNOWN");
+            // validate pool token and product token are same
+
+            // register with tresury
+            // implement and add validation
+            NftId distributorNftId = zeroNftId();
+            _treasuryModule.registerProduct(
+                nftId,
+                distributorNftId,
+                poolNftId,
+                token,
+                wallet,
+                product.getPolicyFee(),
+                product.getProcessingFee()
+            );
+        } else if (component.getType() == POOL()) {
+            IPoolComponent pool = IPoolComponent(address(component));
+
+            // register with pool
+            _poolModule.registerPool(nftId);
+
+            // register with tresury
+            _treasuryModule.registerPool(
+                nftId,
+                wallet,
+                pool.getStakingFee(),
+                pool.getPerformanceFee()
+            );
+        }
+        // TODO add distribution
+
+        _nftIdByAddress[address(component)] = nftId;
+        _nftIds.push(nftId);
+
+        // TODO add loggingx
+    }
+
+    function getComponentOwnerService()
+        external
+        view
+        override
+        returns (IComponentOwnerService)
+    {
+        return _componentOwnerService;
+    }
+
+    function setComponentInfo(
+        ComponentInfo memory info
+    ) external onlyComponentOwnerService returns (NftId nftId) {
+        nftId = info.nftId;
+        require(
+            nftId.gtz() && _componentInfo[nftId].nftId.eq(nftId),
+            "ERROR:CMP-006:COMPONENT_UNKNOWN"
+        );
+
+        // TODO decide if state changes should have explicit functions and not
+        // just a generic setXYZInfo and implicit state transitions
+        // when in doubt go for the explicit approach ...
+        ObjectType objectType = this.getRegistry().getInfo(nftId).objectType;
+        _lifecycleModule.checkAndLogTransition(
+            nftId,
+            objectType,
+            _componentInfo[nftId].state,
+            info.state
+        );
+        _componentInfo[nftId] = info;
+    }
+
+    function getComponentInfo(
+        NftId nftId
+    ) external view override returns (ComponentInfo memory) {
+        return _componentInfo[nftId];
+    }
+
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId componentNftId) {
+        return _nftIdByAddress[componentAddress];
+    }
+
+    function getComponentId(
+        uint256 idx
+    ) external view override returns (NftId componentNftId) {
+        return _nftIds[idx];
+    }
+
+    function components()
+        external
+        view
+        override
+        returns (uint256 numberOfCompnents)
+    {
+        return _nftIds.length;
+    }
+
+    function getRoleForType(
+        ObjectType cType
+    ) public view returns (bytes32 role) {
+        if (cType == PRODUCT()) {
+            return this.PRODUCT_OWNER_ROLE();
+        }
+        if (cType == POOL()) {
+            return this.POOL_OWNER_ROLE();
+        }
+        if (cType == ORACLE()) {
+            return this.ORACLE_OWNER_ROLE();
+        }
+    }
+}
+
+// this is actually the component owner service
+contract ComponentOwnerService is
+    RegistryLinked,
+    IComponent,
+    IComponentOwnerService
+{
+    using NftIdLib for NftId;
+
+    modifier onlyComponentOwner(IComponentContract component) {
+        NftId nftId = _registry.getNftId(address(component));
+        require(nftId.gtz(), "ERROR:COS-001:COMPONENT_UNKNOWN");
+        require(
+            msg.sender == _registry.getOwner(nftId),
+            "ERROR:COS-002:NOT_OWNER"
+        );
+        _;
+    }
+
+    constructor(
+        address registry
+    ) RegistryLinked(registry) // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    function register(
+        IComponentContract component
+    ) external override returns (NftId nftId) {
+        require(
+            msg.sender == component.getInitialOwner(),
+            "ERROR:COS-003:NOT_OWNER"
+        );
+
+        IInstance instance = component.getInstance();
+        nftId = instance.registerComponent(component);
+    }
+
+    function lock(
+        IComponentContract component
+    ) external override onlyComponentOwner(component) {
+        IInstance instance = component.getInstance();
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
+
+        info.state = PAUSED();
+        // setComponentInfo checks for valid state changes
+        instance.setComponentInfo(info);
+    }
+
+    function unlock(
+        IComponentContract component
+    ) external override onlyComponentOwner(component) {
+        IInstance instance = component.getInstance();
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
+
+        info.state = ACTIVE();
+        // setComponentInfo checks for valid state changes
+        instance.setComponentInfo(info);
+    }
+
+    function setProductFees(
+        IComponentContract product,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external override onlyComponentOwner(product) {
+        require(product.getType() == PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        address instanceAddress = address(product.getInstance());
+        ITreasuryModule treasuryModule = ITreasuryModule(instanceAddress);
+        treasuryModule.setProductFees(
+            product.getNftId(),
+            policyFee,
+            processingFee
+        );
+    }
+}

package/contracts/instance/component/IComponent.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IInstance} from "../IInstance.sol";
+import {StateId} from "../../types/StateId.sol";
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {UFixed} from "../../types/UFixed.sol";
+
+interface IComponent {
+    // component dynamic info (static info kept in registry)
+    struct ComponentInfo {
+        NftId nftId;
+        StateId state;
+        IERC20Metadata token;
+    }
+}
+
+interface IInstanceLinked {
+    // function setInstance(address instance) external;
+    function getInstance() external view returns (IInstance instance);
+}
+
+interface IComponentContract is IRegisterable, IInstanceLinked, IComponent {
+    function getToken() external view returns (IERC20Metadata token);
+
+    function getWallet() external view returns (address walletAddress);
+}
+
+interface IComponentOwnerService is IRegistryLinked {
+    function register(
+        IComponentContract component
+    ) external returns (NftId nftId);
+
+    function lock(IComponentContract component) external;
+
+    function unlock(IComponentContract component) external;
+
+    function setProductFees(
+        IComponentContract product,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external;
+}
+
+interface IComponentModule is IOwnable, IRegistryLinked, IComponent {
+    function registerComponent(
+        IComponentContract component
+    ) external returns (NftId nftId);
+
+    function setComponentInfo(
+        ComponentInfo memory info
+    ) external returns (NftId componentNftId);
+
+    function getComponentInfo(
+        NftId nftId
+    ) external view returns (ComponentInfo memory info);
+
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId nftId);
+
+    function getComponentId(uint256 idx) external view returns (NftId nftId);
+
+    function components() external view returns (uint256 numberOfCompnents);
+
+    function getComponentOwnerService()
+        external
+        view
+        returns (IComponentOwnerService);
+}

package/contracts/instance/lifecycle/ILifecycle.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ObjectType} from "../../types/ObjectType.sol";
+import {StateId, toStateId, zeroStateId} from "../../types/StateId.sol";
+import {NftId} from "../../types/NftId.sol";
+
+interface ILifecycle {
+    event LogComponentStateChanged(
+        NftId nftId,
+        ObjectType objectType,
+        StateId fromStateId,
+        StateId toStateId
+    );
+    event LogBundleStateChanged(
+        NftId nftId,
+        StateId fromStateId,
+        StateId toStateId
+    );
+    event LogPolicyStateChanged(
+        NftId nftId,
+        StateId fromStateId,
+        StateId toStateId
+    );
+    // event LogClaimStateChanged(NftId nftId, ClaimId claimId, StateId fromStateId, StateId toStateId);
+    // event LogPayoutStateChanged(NftId nftId, ClaimId claimId, PayoutId payoutId, StateId fromStateId, StateId toStateId);
+
+    error ErrorNoLifecycle(NftId nftId, ObjectType objectType);
+    error ErrorInvalidStateTransition(
+        NftId nftId,
+        ObjectType objectType,
+        StateId fromStateId,
+        StateId toStateId
+    );
+}
+
+interface ILifecycleModule is ILifecycle {
+    function getInitialState(
+        ObjectType objectType
+    ) external view returns (StateId);
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) external view returns (bool);
+}