@etherisc/gif-next 0.0.2-cf68d0c-530 → 0.0.2-d02cb80-460

package/contracts/instance/service/PoolService.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Pool} from "../../components/Pool.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {IBundle} from "../../instance/module/IBundle.sol";
+import {TokenHandler} from "../../instance/module/ITreasury.sol";
+import {ISetup} from "../module/ISetup.sol";
+import {IPolicy} from "../module/IPolicy.sol";
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {Versionable} from "../../shared/Versionable.sol";
+import {INftOwnable} from "../../shared/INftOwnable.sol";
+
+import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
+import {POOL, BUNDLE} from "../../types/ObjectType.sol";
+import {POOL_OWNER_ROLE, RoleId} from "../../types/RoleId.sol";
+import {Fee, FeeLib} from "../../types/Fee.sol";
+import {Version, VersionLib} from "../../types/Version.sol";
+import {KEEP_STATE, StateId} from "../../types/StateId.sol";
+import {TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
+
+import {IService} from "../../shared/IService.sol";
+import {Service} from "../../shared/Service.sol";
+import {BundleManager} from "../BundleManager.sol";
+import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {IPoolService} from "./IPoolService.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
+import {InstanceService} from "../InstanceService.sol";
+import {InstanceReader} from "../InstanceReader.sol";
+import {IBaseComponent} from "../../components/IBaseComponent.sol";
+
+string constant POOL_SERVICE_NAME = "PoolService";
+
+contract PoolService is 
+    ComponentServiceBase, 
+    IPoolService 
+{
+    using NftIdLib for NftId;
+
+    string public constant NAME = "PoolService";
+
+    address internal _registryAddress;
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        initializer
+        virtual override
+    {
+        address registryAddress;
+        address initialOwner;
+        (registryAddress, initialOwner) = abi.decode(data, (address, address));
+        // TODO while PoolService is not deployed in PoolServiceManager constructor
+        //      owner is PoolServiceManager deployer
+        _initializeService(registryAddress, owner);
+
+        _registerInterface(type(IPoolService).interfaceId);
+    }
+
+    function getName() public pure override(Service, IService) returns(string memory name) {
+        return NAME;
+    }
+
+    function register(address poolAddress) 
+        external
+        returns(NftId poolNftId)
+    {
+        address poolOwner = msg.sender;
+        IBaseComponent pool = IBaseComponent(poolAddress);
+
+        IRegistry.ObjectInfo memory info;
+        bytes memory data;
+        (info, data) = getRegistryService().registerPool(pool, poolOwner);
+
+        IInstance instance = _getInstance(info);
+
+        bool hasRole = getInstanceService().hasRole(
+            poolOwner, 
+            POOL_OWNER_ROLE(), 
+            address(instance));
+
+        if(!hasRole) {
+            revert ExpectedRoleMissing(POOL_OWNER_ROLE(), poolOwner);
+        }
+
+        poolNftId = info.nftId;
+        ISetup.PoolSetupInfo memory initialSetup = _decodeAndVerifyPoolSetup(data);
+        instance.createPoolSetup(poolNftId, initialSetup);
+    }
+
+    function _decodeAndVerifyPoolSetup(bytes memory data) internal returns(ISetup.PoolSetupInfo memory setup)
+    {
+        setup = abi.decode(
+            data,
+            (ISetup.PoolSetupInfo)
+        );
+
+        // TODO add checks if applicable 
+    }
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        external
+        override
+    {
+        (IRegistry.ObjectInfo memory poolInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId poolNftId = poolInfo.nftId;
+
+        ISetup.PoolSetupInfo memory poolSetupInfo = instanceReader.getPoolSetupInfo(poolNftId);
+        poolSetupInfo.poolFee = poolFee;
+        poolSetupInfo.stakingFee = stakingFee;
+        poolSetupInfo.performanceFee = performanceFee;
+        
+        instance.updatePoolSetup(poolNftId, poolSetupInfo, KEEP_STATE());
+    }
+}

package/contracts/instance/service/PoolServiceManager.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {ProxyManager} from "../../shared/ProxyManager.sol";
+import {PoolService} from "./PoolService.sol";
+import {Registry} from "../../registry/Registry.sol";
+import {RegistryService} from "../../registry/RegistryService.sol";
+import {VersionLib} from "../../types/Version.sol";
+
+contract PoolServiceManager is ProxyManager {
+
+    PoolService private _poolService;
+
+    /// @dev initializes proxy manager with pool service implementation 
+    constructor(
+        address registryAddress
+    )
+        ProxyManager()
+    {
+        PoolService poolSrv = new PoolService();
+        bytes memory data = abi.encode(registryAddress, address(this));
+        IVersionable versionable = deploy(
+            address(poolSrv), 
+            data);
+
+        _poolService = PoolService(address(versionable));
+
+        Registry registry = Registry(registryAddress);
+        address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        RegistryService registryService = RegistryService(registryServiceAddress);
+        // TODO this must have a role or own nft to register service
+        //registryService.registerService(_poolService);
+        
+        // TODO no nft to link yet
+        // link ownership of instance service manager ot nft owner of instance service
+        //_linkToNftOwnable(
+        //    address(registryAddress),
+        //    address(_poolService));
+
+        // implies that after this constructor call only upgrade functionality is available
+        _isDeployed = true;
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getPoolService()
+        external
+        view
+        returns (PoolService poolService)
+    {
+        return _poolService;
+    }
+
+}

package/contracts/instance/service/ProductService.sol

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IProductComponent} from "../../components/IProductComponent.sol";
+import {Product} from "../../components/Product.sol";
+import {IBaseComponent} from "../../components/IBaseComponent.sol";
+import {IPoolComponent} from "../../components/IPoolComponent.sol";
+import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
+import {IInstance} from "../IInstance.sol";
+import {IPolicy} from "../module/IPolicy.sol";
+import {IRisk} from "../module/IRisk.sol";
+import {IBundle} from "../module/IBundle.sol";
+import {IProductService} from "./IProductService.sol";
+import {ITreasury} from "../module/ITreasury.sol";
+import {ISetup} from "../module/ISetup.sol";
+
+import {TokenHandler} from "../../shared/TokenHandler.sol";
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {Versionable} from "../../shared/Versionable.sol";
+
+import {Timestamp, zeroTimestamp} from "../../types/Timestamp.sol";
+import {UFixed, UFixedLib} from "../../types/UFixed.sol";
+import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
+import {ObjectType, INSTANCE, PRODUCT, POLICY} from "../../types/ObjectType.sol";
+import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE} from "../../types/StateId.sol";
+import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
+import {Fee, FeeLib} from "../../types/Fee.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {RiskId} from "../../types/RiskId.sol";
+import {StateId} from "../../types/StateId.sol";
+import {Version, VersionLib} from "../../types/Version.sol";
+import {RoleId, PRODUCT_OWNER_ROLE} from "../../types/RoleId.sol";
+
+import {IService} from "../../shared/IService.sol";
+import {Service} from "../../shared/Service.sol";
+import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {IProductService} from "./IProductService.sol";
+import {InstanceReader} from "../InstanceReader.sol";
+import {IPoolService} from "./PoolService.sol";
+import {POOL_SERVICE_NAME} from "./PoolService.sol";
+
+string constant PRODUCT_SERVICE_NAME = "ProductService";
+
+// TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
+contract ProductService is ComponentServiceBase, IProductService {
+    using NftIdLib for NftId;
+
+    string public constant NAME = "ProductService";
+
+    IPoolService internal _poolService;
+
+    event LogProductServiceSender(address sender);
+
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        initializer
+        virtual override
+    {
+        address registryAddress;
+        address initialOwner;
+        (registryAddress, initialOwner) = abi.decode(data, (address, address));
+
+        _initializeService(registryAddress, owner);
+
+        _poolService = IPoolService(_registry.getServiceAddress(POOL_SERVICE_NAME, getMajorVersion()));
+
+        _registerInterface(type(IProductService).interfaceId);
+    }
+
+
+    function getName() public pure override(IService, Service) returns(string memory name) {
+        return NAME;
+    }
+
+    function register(address productAddress) 
+        external
+        returns(NftId productNftId)
+    {
+        address productOwner = msg.sender;
+        IBaseComponent product = IBaseComponent(productAddress);
+
+        IRegistry.ObjectInfo memory info;
+        bytes memory data;
+        (info, data) = getRegistryService().registerProduct(product, productOwner);
+
+        IInstance instance = _getInstance(info);
+        bool hasRole = getInstanceService().hasRole(
+            productOwner, 
+            PRODUCT_OWNER_ROLE(), 
+            address(instance));
+
+        if(!hasRole) {
+            revert ExpectedRoleMissing(PRODUCT_OWNER_ROLE(), productOwner);
+        }
+
+        productNftId = info.nftId;
+        ISetup.ProductSetupInfo memory initialSetup = _decodeAndVerifyProductSetup(data);
+        instance.createProductSetup(productNftId, initialSetup);
+    }
+
+    function _decodeAndVerifyProductSetup(bytes memory data) internal returns(ISetup.ProductSetupInfo memory setup)
+    {
+        setup = abi.decode(
+            data,
+            (ISetup.ProductSetupInfo)
+        );
+
+        // TODO add checks if applicable 
+    }
+
+    function setFees(
+        Fee memory productFee,
+        Fee memory processingFee
+    )
+        external
+    {
+        // TODO check args 
+
+        (
+            IRegistry.ObjectInfo memory productInfo, 
+            IInstance instance
+        ) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId productNftId = productInfo.nftId;
+        ISetup.ProductSetupInfo memory productSetupInfo = instanceReader.getProductSetupInfo(productNftId);
+
+        productSetupInfo.productFee = productFee;
+        productSetupInfo.processingFee = processingFee;
+        
+        instance.updateProductSetup(productNftId, productSetupInfo, KEEP_STATE());
+    }
+
+    function createRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external override {
+        (
+            IRegistry.ObjectInfo memory productInfo, 
+            IInstance instance
+        ) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        NftId productNftId = productInfo.nftId;
+        IRisk.RiskInfo memory riskInfo = IRisk.RiskInfo(productNftId, data);
+        instance.createRisk(
+            riskId,
+            riskInfo
+        );
+    }
+
+    function updateRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external {
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        IRisk.RiskInfo memory riskInfo = instanceReader.getRiskInfo(riskId);
+        riskInfo.data = data;
+        instance.updateRisk(riskId, riskInfo, KEEP_STATE());
+    }
+
+    function updateRiskState(
+        RiskId riskId,
+        StateId state
+    ) external {
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        instance.updateRiskState(riskId, state);
+    }
+}

package/contracts/instance/service/ProductServiceManager.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {ProxyManager} from "../../shared/ProxyManager.sol";
+import {ProductService} from "./ProductService.sol";
+import {Registry} from "../../registry/Registry.sol";
+import {RegistryService} from "../../registry/RegistryService.sol";
+import {VersionLib} from "../../types/Version.sol";
+
+contract ProductServiceManager is ProxyManager {
+
+    ProductService private _productService;
+
+    /// @dev initializes proxy manager with product service implementation 
+    constructor(
+        address registryAddress
+    )
+        ProxyManager()
+    {
+        ProductService svc = new ProductService();
+        bytes memory data = abi.encode(registryAddress, address(this));
+        IVersionable versionable = deploy(
+            address(svc), 
+            data);
+
+        _productService = ProductService(address(versionable));
+
+        // Registry registry = Registry(registryAddress);
+        // address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        // RegistryService registryService = RegistryService(registryServiceAddress);
+        // TODO this must have a role or own nft to register service
+        //registryService.registerService(_productService);
+        
+        // TODO no nft to link yet
+        // link ownership of instance service manager ot nft owner of instance service
+        //_linkToNftOwnable(
+        //    address(registryAddress),
+        //    address(_productService));
+
+        // implies that after this constructor call only upgrade functionality is available
+        _isDeployed = true;
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getProductService()
+        external
+        view
+        returns (ProductService productService)
+    {
+        return _productService;
+    }
+
+}

package/contracts/registry/IRegistry.sol

@@ -13,30 +13,19 @@ interface IRegistry is IERC165 {
     event LogInitialMajorVersionSet(VersionPart majorVersion);
     event LogMajorVersionSet(VersionPart majorVersionMax);
     event LogRegistration(ObjectInfo info);
-    event LogTokenStateSet(address token, VersionPart majorVersion, bool active);
     event LogServiceNameRegistration(string serviceName, VersionPart majorVersion); 
 
-    // supported versions
+    // setMajorVersion()
+    error NotOwner(address account);
     error MajorVersionMaxIncreaseInvalid(VersionPart newMajorVersionMax, VersionPart existingMaxMajorVersion);
 
-    // token whitelisting
-    error TokenNotRegistered(address token);
-    error NotToken(address token);
-    error TokenMajorVersionInvalid(VersionPart majorVersion);
-
-    // register
+    // register()
     error NotRegistryService();
     error ZeroParentAddress();
+    error InvalidTypesCombination(ObjectType objectType, ObjectType parentType);
     error ContractAlreadyRegistered(address objectAddress);
     error InvalidServiceVersion(VersionPart majorVersion);
     error ServiceNameAlreadyRegistered(string name, VersionPart majorVersion);
-            
-    // approve
-    error NotOwner(address account);
-    error NotRegisteredContract(NftId registrarNftId);
-    error NotService(NftId registrarNftId);
-    error InvalidTypesCombination(ObjectType objectType, ObjectType parentType);
-
 
     struct ObjectInfo {
         NftId nftId;
@@ -53,8 +42,6 @@ interface IRegistry is IERC165 {
 
     function register(ObjectInfo memory info) external returns (NftId nftId);
 
-    function setTokenActive(address token, VersionPart majorVersion, bool active) external;
-
     function getMajorVersionMin() external view returns (VersionPart);
 
     function getMajorVersionMax() external view returns (VersionPart);
@@ -79,7 +66,7 @@ interface IRegistry is IERC165 {
 
     function isRegistered(address contractAddress) external view returns (bool);
 
-    function isTokenActive(address token, VersionPart majorVersion) external view returns (bool);
+    function isRegisteredService(address contractAddress) external view returns (bool);
 
     function getServiceName(NftId nftId) external view returns (string memory name);
 

package/contracts/registry/IRegistryService.sol

@@ -12,22 +12,39 @@ import {IBaseComponent} from "../components/IBaseComponent.sol";
 
 interface IRegistryService is IService {
 
-    function registerService(IService service)  external returns(IRegistry.ObjectInfo memory info, bytes memory data);
+     error SelfRegistration();
+     error NotRegistryOwner();
 
-    function registerInstance(IRegisterable instance)
-        external returns(IRegistry.ObjectInfo memory info, bytes memory data); 
+     error NotService();
+     error NotInstance();
+     error NotProduct();
+     error NotPool();
+     error NotDistribution();
 
-    function registerProduct(IBaseComponent product, address owner)
-         external returns(IRegistry.ObjectInfo memory info, bytes memory data);
+     error UnexpectedRegisterableType(ObjectType expected, ObjectType found);
+     error NotRegisterableOwner(address expectedOwner);
+     error RegisterableOwnerIsZero();   
+     error RegisterableOwnerIsRegistered();
+     error InvalidInitialOwner(address initialOwner);
+     error InvalidAddress(address registerableAddress);
 
-    function registerPool(IBaseComponent pool, address owner)
-         external returns(IRegistry.ObjectInfo memory info, bytes memory data);
 
-    function registerDistribution(IBaseComponent distribution, address owner)
-         external returns(IRegistry.ObjectInfo memory info, bytes memory data);
+     function registerService(IService service)  external returns(IRegistry.ObjectInfo memory info, bytes memory data);
 
-    function registerPolicy(IRegistry.ObjectInfo memory info) external returns(NftId nftId); // -> easy to upgrade
+     function registerInstance(IRegisterable instance)
+          external returns(IRegistry.ObjectInfo memory info, bytes memory data); 
 
-    function registerBundle(IRegistry.ObjectInfo memory info) external returns(NftId nftId); 
+     function registerProduct(IBaseComponent product, address owner)
+          external returns(IRegistry.ObjectInfo memory info, bytes memory data);
+
+     function registerPool(IBaseComponent pool, address owner)
+          external returns(IRegistry.ObjectInfo memory info, bytes memory data);
+
+     function registerDistribution(IBaseComponent distribution, address owner)
+          external returns(IRegistry.ObjectInfo memory info, bytes memory data);
+
+     function registerPolicy(IRegistry.ObjectInfo memory info) external returns(NftId nftId); // -> easy to upgrade
+
+     function registerBundle(IRegistry.ObjectInfo memory info) external returns(NftId nftId); 
 }
 

package/contracts/registry/Registry.sol

@@ -30,6 +30,7 @@ contract Registry is
 {
     uint256 public constant GIF_MAJOR_VERSION_AT_DEPLOYMENT = 3;
     address public constant NFT_LOCK_ADDRESS = address(0x1);
+    uint256 public constant REGISTRY_TOKEN_SEQUENCE_ID = 2;
     uint256 public constant REGISTRY_SERVICE_TOKEN_SEQUENCE_ID = 3;
     string public constant EMPTY_URI = "";
 
@@ -38,18 +39,12 @@ contract Registry is
     mapping(NftId nftId => ObjectInfo info) internal _info;
     mapping(address object => NftId nftId) internal _nftIdByAddress;
 
-    mapping(NftId registrator => mapping(
-            ObjectType objectType => bool)) internal _isApproved;
-
     mapping(ObjectType objectType => mapping(
             ObjectType parentType => bool)) internal _isValidContractCombination;
 
     mapping(ObjectType objectType => mapping(
             ObjectType parentType => bool)) internal _isValidObjectCombination;
 
-    mapping(address token => mapping(
-            VersionPart majorVersion => bool isActive)) internal _tokenIsActive;
-
     mapping(NftId nftId => string name) internal _string;
     mapping(bytes32 serviceNameHash => mapping(
             VersionPart majorVersion => address service)) internal _service;
@@ -67,7 +62,6 @@ contract Registry is
     }
 
     modifier onlyRegistryService() {
-        
         if(msg.sender != _info[_serviceNftId].objectAddress) {
             revert NotRegistryService();
         }
@@ -181,38 +175,6 @@ contract Registry is
 
         emit LogRegistration(info);
     }
-
-    /// @dev token state is informative, registry have no clue about used tokens
-    // component owner is responsible for token selection and operations
-    // service MUST deny registration of component with inactive token 
-    function setTokenActive(address token, VersionPart majorVersion, bool active)
-        external
-        onlyOwner
-    {
-        // verify that token is registered
-        ObjectInfo memory info = _info[_nftIdByAddress[token]];
-        if (info.nftId.eqz()) {
-            revert TokenNotRegistered(token);
-        }
-
-        // verify provided address is a registered token
-        if (info.objectType != TOKEN()) {
-            revert NotToken(token);
-        }
-
-        // verify valid major version
-        // ensure major version increments is one
-        uint256 version = majorVersion.toInt();
-        uint256 versionNow = _majorVersion.toInt();
-        if (version < GIF_MAJOR_VERSION_AT_DEPLOYMENT || version > versionNow) {
-            revert TokenMajorVersionInvalid(majorVersion);
-        }
-
-        _tokenIsActive[token][majorVersion] = active;
-
-        emit LogTokenStateSet(token, majorVersion, active);
-    }
-
     /// @dev earliest GIF major version 
     function getMajorVersionMin() external view returns (VersionPart) {
         return VersionLib.toVersionPart(GIF_MAJOR_VERSION_AT_DEPLOYMENT);
@@ -233,7 +195,6 @@ contract Registry is
     function getMajorVersion() external view returns (VersionPart) { 
         return _majorVersion;
     }
-    
 
     function getObjectCount() external view override returns (uint256) {
         return _chainNft.totalSupply();
@@ -252,7 +213,6 @@ contract Registry is
     }
 
     function ownerOf(address contractAddress) public view returns (address) {
-        
         return _chainNft.ownerOf(_nftIdByAddress[contractAddress].toInt());
     }
 
@@ -261,7 +221,6 @@ contract Registry is
     }
 
     function getObjectInfo(address object) external view override returns (ObjectInfo memory) {
-        
         return _info[_nftIdByAddress[object]];
     }
 
@@ -273,8 +232,8 @@ contract Registry is
         return _nftIdByAddress[object].gtz();
     }
 
-    function isTokenActive(address token, VersionPart majorVersion) external view returns (bool) {
-        return _tokenIsActive[token][majorVersion];
+    function isRegisteredService(address object) external view override returns (bool) {
+        return _nftIdByAddress[object].gtz() && _info[_nftIdByAddress[object]].objectType == SERVICE();
     }
 
     function getServiceName(NftId nftId) external view returns (string memory) {
@@ -378,7 +337,7 @@ contract Registry is
     function _registerRegistry(address registryOwner) 
         internal
     {
-        uint256 registryId = _chainNft.calculateTokenId(2);
+        uint256 registryId = _chainNft.calculateTokenId(REGISTRY_TOKEN_SEQUENCE_ID);
         NftId registryNftId = toNftId(registryId);
 
         NftId parentNftId;