@etherisc/gif-next 0.0.2-e6a90b9 → 0.0.2-e6ad61d-739

package/contracts/instance/component/ComponentModule.sol

@@ -1,194 +1,207 @@
 // 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 
+abstract contract ComponentModule is
     IRegistryLinked,
     IAccessComponentTypeRoles,
     IAccessCheckRole,
     IComponentModule
 {
+    using NftIdLib for NftId;
 
-    mapping(uint256 nftId => ComponentInfo info) private _componentInfo;
-    mapping(uint256 nftId => uint256 poolNftId) private _poolNftIdForProduct;
-    mapping(address cAddress => uint256 id) private _idByAddress;
-    uint256 [] private _ids;
+    mapping(NftId nftId => ComponentInfo info) private _componentInfo;
+    mapping(address cAddress => NftId nftId) private _nftIdByAddress;
+    NftId[] private _nftIds;
 
-    mapping(uint256 cType => bytes32 role) private _componentOwnerRole;
+    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");
+        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(uint256 nftId)
-    {
-        bytes32 typeRole = getRoleForType(component.getType());
+    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");
-        
+            "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,
-            CState.Active);
+            _lifecycleModule.getInitialState(objectType),
+            token
+        );
 
-        // special case product -> persist product - pool assignment
-        if(component.getType() == this.getRegistry().PRODUCT()) {
+        // component type specific registration actions
+        if (component.getType() == PRODUCT()) {
             IProductComponent product = IProductComponent(address(component));
-            uint256 poolNftId = product.getPoolNftId();
-            require(poolNftId > 0, "ERROR:CMP-005:POOL_UNKNOWN");
-            // add more validation (type, token, ...)
+            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));
 
-            _poolNftIdForProduct[nftId] = poolNftId;
+            // register with pool
+            _poolModule.registerPool(nftId);
 
-            // add creation of productInfo
-        }
-        else if(component.getType() == this.getRegistry().POOL()) {
-            IPoolModule poolModule = IPoolModule(address(this));
-            poolModule.createPoolInfo(
+            // register with tresury
+            _treasuryModule.registerPool(
                 nftId,
-                address(component), // set pool as its wallet
-                address(0) // don't deal with token yet
+                wallet,
+                pool.getStakingFee(),
+                pool.getPerformanceFee()
             );
         }
+        // TODO add distribution
 
-        _idByAddress[address(component)] = nftId;
-        _ids.push(nftId);
-
-        // add logging
-    }
+        _nftIdByAddress[address(component)] = nftId;
+        _nftIds.push(nftId);
 
-    function getPoolNftId(uint256 productNftId)
-        external
-        view
-        override
-        returns(uint256 poolNftId)
-    {
-        poolNftId = _poolNftIdForProduct[productNftId];
+        // TODO add loggingx
     }
 
-
     function getComponentOwnerService()
         external
-        override
         view
-        returns(IComponentOwnerService)
+        override
+        returns (IComponentOwnerService)
     {
         return _componentOwnerService;
     }
 
-    function setComponentInfo(ComponentInfo memory info)
-        external
-        onlyComponentOwnerService
-        returns(uint256 nftId)
-    {
-        uint256 id = info.nftId;
+    function setComponentInfo(
+        ComponentInfo memory info
+    ) external onlyComponentOwnerService returns (NftId nftId) {
+        nftId = info.nftId;
         require(
-            id > 0 && _componentInfo[id].nftId == id,
-            "ERROR:CMP-006:COMPONENT_UNKNOWN");
-
-        _componentInfo[id] = info;
-
-        // add logging
-    }
+            nftId.gtz() && _componentInfo[nftId].nftId.eq(nftId),
+            "ERROR:CMP-006:COMPONENT_UNKNOWN"
+        );
 
-    function getComponentInfo(uint256 id)
-        external
-        override
-        view
-        returns(ComponentInfo memory)
-    {
-        return _componentInfo[id];
+        // 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 getComponentOwner(uint256 id)
-        external
-        view
-        returns(address owner)
-    {
-
+    function getComponentInfo(
+        NftId nftId
+    ) external view override returns (ComponentInfo memory) {
+        return _componentInfo[nftId];
     }
 
-    function getComponentId(address componentAddress)
-        external
-        view
-        returns(uint256 id)
-    {
-        return _idByAddress[componentAddress];
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId componentNftId) {
+        return _nftIdByAddress[componentAddress];
     }
 
-
-    function getComponentId(uint256 idx)
-        external
-        override
-        view
-        returns(uint256 id)
-    {
-        return _ids[idx];
+    function getComponentId(
+        uint256 idx
+    ) external view override returns (NftId componentNftId) {
+        return _nftIds[idx];
     }
 
-
     function components()
         external
-        override
         view
-        returns(uint256 numberOfCompnents)
+        override
+        returns (uint256 numberOfCompnents)
     {
-        return _ids.length;
+        return _nftIds.length;
     }
 
-    function getRoleForType(uint256 cType)
-        public
-        view
-        returns(bytes32 role)
-    {
-        if(cType == this.getRegistry().PRODUCT()) {
+    function getRoleForType(
+        ObjectType cType
+    ) public view returns (bytes32 role) {
+        if (cType == PRODUCT()) {
             return this.PRODUCT_OWNER_ROLE();
         }
-        if(cType == this.getRegistry().POOL()) {
+        if (cType == POOL()) {
             return this.POOL_OWNER_ROLE();
         }
-        if(cType == this.getRegistry().ORACLE()) {
+        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) {
-        uint256 nftId = _registry.getNftId(address(component));
-        require(
-            nftId > 0, 
-            "ERROR:COS-001:COMPONENT_UNKNOWN");
+        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"
@@ -196,51 +209,66 @@ contract ComponentOwnerService is
         _;
     }
 
-    constructor(address registry)
-        RegistryLinked(registry)
-    { }
-
-    function register(IComponentContract component)
-        external
-        override
-        returns(uint256 nftId)
+    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");
+            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)
-    {
+    function lock(
+        IComponentContract component
+    ) external override onlyComponentOwner(component) {
         IInstance instance = component.getInstance();
-        ComponentInfo memory info = instance.getComponentInfo(component.getNftId());
-        require(info.nftId > 0, "ERROR_COMPONENT_UNKNOWN");
-        // TODO add state change validation
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
 
-        info.state = CState.Locked;
+        info.state = PAUSED();
+        // setComponentInfo checks for valid state changes
         instance.setComponentInfo(info);
     }
 
-
-    function unlock(IComponentContract component)
-        external
-        override
-        onlyComponentOwner(component)
-    {
+    function unlock(
+        IComponentContract component
+    ) external override onlyComponentOwner(component) {
         IInstance instance = component.getInstance();
-        ComponentInfo memory info = instance.getComponentInfo(component.getNftId());
-        require(info.nftId > 0, "ERROR_COMPONENT_UNKNOWN");
-        // TODO state change validation
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
 
-        info.state = CState.Active;
+        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

@@ -1,94 +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 {
-
-    // TODO decide if enum or uints with constants (as in IRegistry.PRODUCT())
-    enum CState {
-        Undefined,
-        Active,
-        Locked
-    }
-
     // component dynamic info (static info kept in registry)
     struct ComponentInfo {
-        uint256 nftId;
-        CState state;
+        NftId nftId;
+        StateId state;
+        IERC20Metadata token;
     }
 }
 
-
 interface IInstanceLinked {
     // function setInstance(address instance) external;
-    function getInstance() external view returns(IInstance instance);
+    function getInstance() external view returns (IInstance instance);
 }
 
+interface IComponentContract is IRegisterable, IInstanceLinked, IComponent {
+    function getToken() external view returns (IERC20Metadata token);
 
-interface IComponentContract is
-    IRegisterable,
-    IInstanceLinked,
-    IComponent
-{ }
-
+    function getWallet() external view returns (address walletAddress);
+}
 
-interface IComponentOwnerService is IRegistryLinked{
+interface IComponentOwnerService is IRegistryLinked {
+    function register(
+        IComponentContract component
+    ) external returns (NftId nftId);
 
-    function register(IComponentContract component) external returns(uint256 id);
     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);
 
-interface IComponentModule is
-    IOwnable,
-    IRegistryLinked,
-    IComponent
-{
+    function setComponentInfo(
+        ComponentInfo memory info
+    ) external returns (NftId componentNftId);
 
-    function registerComponent(IComponentContract component)
-        external
-        returns(uint256 nftInfo);
+    function getComponentInfo(
+        NftId nftId
+    ) external view returns (ComponentInfo memory info);
 
-    function setComponentInfo(ComponentInfo memory info)
-        external
-        returns(uint256 componentId);
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId nftId);
 
-    function getComponentInfo(uint256 id)
-        external
-        view
-        returns(ComponentInfo memory info);
+    function getComponentId(uint256 idx) external view returns (NftId nftId);
 
-    function getComponentOwner(uint256 id)
-        external
-        view
-        returns(address owner);
-
-    function getComponentId(address componentAddress)
-        external
-        view
-        returns(uint256 id);
-
-    function getComponentId(uint256 idx)
-        external
-        view
-        returns(uint256 id);
-
-    function getPoolNftId(uint256 productNftId)
-        external
-        view
-        returns(uint256 poolNftId);
-
-    function components()
-        external
-        view
-        returns(uint256 numberOfCompnents);
+    function components() external view returns (uint256 numberOfCompnents);
 
     function getComponentOwnerService()
         external
         view
-        returns(IComponentOwnerService);
-}
+        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);
+}

package/contracts/instance/lifecycle/LifecycleModule.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType, PRODUCT, ORACLE, POOL, BUNDLE, POLICY} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, REVOKED, DECLINED} from "../../types/StateId.sol";
+import {ILifecycleModule} from "./ILifecycle.sol";
+
+contract LifecycleModule is ILifecycleModule {
+    mapping(ObjectType objectType => StateId initialState)
+        private _initialState;
+
+    mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
+        private _isValidTransition;
+
+    constructor() {
+        _setupComponentLifecycle(PRODUCT());
+        _setupComponentLifecycle(ORACLE());
+        _setupComponentLifecycle(POOL());
+
+        _setupBundleLifecycle();
+        _setupPolicyLifecycle();
+    }
+
+    function checkAndLogTransition(
+        NftId nftId,
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public returns (StateId) // add only currentcontract? would that work?
+    {
+        if (!_isValidTransition[objectType][fromId][toId]) {
+            revert ErrorInvalidStateTransition(nftId, objectType, fromId, toId);
+        }
+
+        if (objectType == POLICY()) {
+            emit LogPolicyStateChanged(nftId, fromId, toId);
+        } else if (objectType == BUNDLE()) {
+            emit LogBundleStateChanged(nftId, fromId, toId);
+        } else if (
+            objectType == PRODUCT() ||
+            objectType == ORACLE() ||
+            objectType == POOL()
+        ) {
+            emit LogComponentStateChanged(nftId, objectType, fromId, toId);
+        } else {
+            revert ErrorNoLifecycle(nftId, objectType);
+        }
+
+        return toId;
+    }
+
+    function getInitialState(
+        ObjectType objectType
+    ) public view returns (StateId) {
+        return _initialState[objectType];
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+
+    function _setupComponentLifecycle(ObjectType objectType) internal {
+        _initialState[objectType] = ACTIVE();
+        _isValidTransition[objectType][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[objectType][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[objectType][PAUSED()][ARCHIVED()] = true;
+    }
+
+    function _setupBundleLifecycle() internal {
+        _initialState[BUNDLE()] = ACTIVE();
+        _isValidTransition[BUNDLE()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[BUNDLE()][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[BUNDLE()][PAUSED()][CLOSED()] = true;
+    }
+
+    function _setupPolicyLifecycle() internal {
+        _initialState[POLICY()] = APPLIED();
+        _isValidTransition[POLICY()][APPLIED()][REVOKED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][DECLINED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
+    }
+}