@etherisc/gif-next 0.0.2-80a82e6 → 0.0.2-836a512-798

package/contracts/instance/component/ComponentModule.sol

@@ -1,17 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import "@openzeppelin/contracts/token/ERC20/IERC20.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 {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 {NftId, NftIdLib} from "../../types/NftId.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,
@@ -20,20 +28,30 @@ abstract contract ComponentModule is
     using NftIdLib for NftId;
 
     mapping(NftId nftId => ComponentInfo info) private _componentInfo;
-    mapping(NftId nftId => NftId poolNftId) private _poolNftIdForProduct;
     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);
     }
 
@@ -43,141 +61,137 @@ abstract contract ComponentModule is
         onlyComponentOwnerService
         returns(NftId nftId)
     {
-        bytes32 typeRole = getRoleForType(component.getType());
+        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));
+        IERC20 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));
             NftId poolNftId = product.getPoolNftId();
             require(poolNftId.gtz(), "ERROR:CMP-005:POOL_UNKNOWN");
-            // add more validation (type, token, ...)
-
-            _poolNftIdForProduct[nftId] = poolNftId;
-
-            // add creation of productInfo
+            // 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() == this.getRegistry().POOL()) {
-            IPoolModule poolModule = IPoolModule(address(this));
-            poolModule.createPoolInfo(
-                nftId,
-                address(component), // set pool as its wallet
-                address(0) // don't deal with token yet
-            );
+        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);
 
-        // add logging
-    }
-
-    function getPoolNftId(NftId productNftId)
-        external
-        view
-        override
-        returns(NftId 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(NftId nftId)
-    {
+    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");
+            "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;
-
-        // add logging
     }
 
-    function getComponentInfo(NftId nftId)
-        external
-        override
-        view
-        returns(ComponentInfo memory)
-    {
+    function getComponentInfo(
+        NftId nftId
+    ) external view override returns (ComponentInfo memory) {
         return _componentInfo[nftId];
     }
 
-    function getComponentOwner(NftId nftId)
-        external
-        view
-        returns(address owner)
-    {
-
-    }
+    function getComponentOwner(
+        NftId nftId
+    ) external view returns (address owner) {}
 
-    function getComponentId(address componentAddress)
-        external
-        view
-        returns(NftId componentNftId)
-    {
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId componentNftId) {
         return _nftIdByAddress[componentAddress];
     }
 
-
-    function getComponentId(uint256 idx)
-        external
-        override
-        view
-        returns(NftId componentNftId)
-    {
+    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 _nftIds.length;
     }
 
-    function getRoleForType(uint256 cType)
+    function getRoleForType(ObjectType cType)
         public
         view
         returns(bytes32 role)
     {
-        if(cType == this.getRegistry().PRODUCT()) {
+        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,
@@ -188,9 +202,7 @@ contract ComponentOwnerService is
 
     modifier onlyComponentOwner(IComponentContract component) {
         NftId nftId = _registry.getNftId(address(component));
-        require(
-            nftId.gtz(), 
-            "ERROR:COS-001:COMPONENT_UNKNOWN");
+        require(nftId.gtz(), "ERROR:COS-001:COMPONENT_UNKNOWN");
         require(
             msg.sender == _registry.getOwner(nftId),
             "ERROR:COS-002:NOT_OWNER"
@@ -198,51 +210,45 @@ contract ComponentOwnerService is
         _;
     }
 
-    constructor(address registry)
-        RegistryLinked(registry)
-    { }
+    constructor(address registry) RegistryLinked(registry) {}
 
-    function register(IComponentContract component)
-        external
-        override
-        returns(NftId nftId)
-    {
+    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());
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
         require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
-        // TODO add state change validation
 
-        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());
+        ComponentInfo memory info = instance.getComponentInfo(
+            component.getNftId()
+        );
         require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
-        // TODO state change validation
 
-        info.state = CState.Active;
+        info.state = ACTIVE();
+        // setComponentInfo checks for valid state changes
         instance.setComponentInfo(info);
     }
-
-}
+}

package/contracts/instance/component/IComponent.sol

@@ -1,95 +1,76 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import "@openzeppelin/contracts/token/ERC20/IERC20.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 {
         NftId nftId;
-        CState state;
+        StateId state;
+        IERC20 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(IERC20 token);
+    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(NftId nftId);
     function lock(IComponentContract component) external;
+
     function unlock(IComponentContract component) external;
 }
 
+interface IComponentModule is IOwnable, IRegistryLinked, IComponent {
+    function registerComponent(
+        IComponentContract component
+    ) external returns (NftId nftId);
 
-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 setComponentInfo(
+        ComponentInfo memory info
+    ) external returns (NftId componentNftId);
 
-    function getComponentOwner(NftId nftId)
-        external
-        view
-        returns(address owner);
+    function getComponentInfo(
+        NftId nftId
+    ) external view returns (ComponentInfo memory info);
 
-    function getComponentId(address componentAddress)
-        external
-        view
-        returns(NftId nftId);
+    function getComponentOwner(
+        NftId nftId
+    ) external view returns (address owner);
 
-    function getComponentId(uint256 idx)
-        external
-        view
-        returns(NftId nftId);
+    function getComponentId(
+        address componentAddress
+    ) external view returns (NftId nftId);
 
-    function getPoolNftId(NftId productNftId)
-        external
-        view
-        returns(NftId poolNftId);
+    function getComponentId(uint256 idx) external view returns (NftId nftId);
 
-    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,32 @@
+// 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,91 @@
+// 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;
+    }
+}