@etherisc/gif-next 0.0.2-f74fcad-685 → 0.0.2-f79a517-071

package/contracts/instance/service/ComponentOwnerService.sol

@@ -0,0 +1,315 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IInstance} from "../IInstance.sol";
+
+import {ITreasury, ITreasuryModule} from "../module/treasury/ITreasury.sol";
+import {TreasuryModule} from "../module/treasury/TreasuryModule.sol";
+import {IComponent, IComponentModule} from "../module/component/IComponent.sol";
+import {IBaseComponent} from "../../components/IBaseComponent.sol";
+import {IPoolComponent} from "../../components/IPoolComponent.sol";
+import {IKeyValueStore} from "../../instance/base/IKeyValueStore.sol";
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {Versionable} from "../../shared/Versionable.sol";
+
+import {RoleId, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE, DISTRIBUTION_OWNER_ROLE, ORACLE_OWNER_ROLE} from "../../types/RoleId.sol";
+import {ObjectType, TOKEN, COMPONENT, PRODUCT, ORACLE, POOL, DISTRIBUTION} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED} from "../../types/StateId.sol";
+import {Key32} from "../../types/Key32.sol";
+import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {Version, VersionLib} from "../../types/Version.sol";
+import {UFixed, UFixedLib} from "../../types/UFixed.sol";
+
+import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
+import {IPoolComponent} from "../../components/IPoolComponent.sol";
+import {IProductComponent} from "../../components/IProductComponent.sol";
+import {IService} from "../base/IService.sol";
+import {IComponentOwnerService} from "./IComponentOwnerService.sol";
+import {ServiceBase} from "../base/ServiceBase.sol";
+import {IPool, IPoolModule} from "../module/pool/IPoolModule.sol";
+
+import {IRegistryService} from "../../registry/IRegistryService.sol";
+
+contract ComponentOwnerService is
+    ServiceBase,
+    IComponentOwnerService
+{
+    using NftIdLib for NftId;
+
+    error MissingTypeRole();
+    error WalletIsZero();
+    error InvalidToken();
+    error InvalidPool();
+    error InvalidDistribution();
+    error InvalidPoolsInstance();
+    error InvalidDistributionsInstance();
+
+    error CollateralizationLevelIsZero();
+
+    string public constant NAME = "ComponentOwnerService";
+
+    modifier onlyRegisteredComponent(IBaseComponent component) {
+        NftId nftId = getRegistry().getNftId(address(component));
+        require(nftId.gtz(), "ERROR:COS-001:COMPONENT_UNKNOWN");
+        _;
+    }
+
+    constructor(
+        address registry,
+        NftId registryNftId,
+        address initialOwner
+    )
+    {
+        _initializeServiceBase(registry, registryNftId, initialOwner);
+        _registerInterface(type(IComponentOwnerService).interfaceId);
+    }
+
+    function getName() public pure override(IService, ServiceBase) returns(string memory name) {
+        return NAME;
+    }
+
+    function getRoleForType(
+        ObjectType cType
+    ) public pure override returns (RoleId role) {
+        if (cType == PRODUCT()) {
+            return PRODUCT_OWNER_ROLE();
+        }
+        if (cType == POOL()) {
+            return POOL_OWNER_ROLE();
+        }
+        if (cType == DISTRIBUTION()) {
+            return DISTRIBUTION_OWNER_ROLE();
+        }
+        if (cType == ORACLE()) {
+            return ORACLE_OWNER_ROLE();
+        }
+    }
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        address service = getRegistry().getServiceAddress("RegistryService", getMajorVersion());
+        return IRegistryService(service);
+    }
+
+    function registerProduct(	
+        IBaseComponent product
+    ) external returns (NftId nftId) {	
+
+        // TODO some info parameters from component and from register may differ -> getObjectInfo() after registration?
+        (
+            IRegistry.ObjectInfo memory info,
+            bytes memory data
+        ) = getRegistryService().registerProduct(
+            product,
+            msg.sender);	
+
+        NftId instanceNftId = info.parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        IInstance instance = IInstance(instanceAddress);
+
+        RoleId typeRole = getRoleForType(PRODUCT());
+        // TODO refactor to use access manager infra
+        // if(instance.hasRole(typeRole, msg.sender) == false) {
+        //     revert MissingTypeRole();
+        // }
+        
+        _registerProduct(
+                info.nftId, 
+                instanceNftId,
+                instance,
+                data
+        );
+    }
+
+    function registerPool(	
+        IBaseComponent pool
+    ) external returns (NftId nftId) {	
+
+        // TODO some info parameters from component and from register may differ -> getObjectInfo() after registration?
+        (
+            IRegistry.ObjectInfo memory info,
+            bytes memory data
+        ) = getRegistryService().registerPool(
+            pool,
+            msg.sender);	
+
+        NftId instanceNftId = info.parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        IInstance instance = IInstance(instanceAddress);
+
+        RoleId typeRole = getRoleForType(POOL());
+        // TODO refactor to use access manager infra
+        // if(instance.hasRole(typeRole, msg.sender) == false) {
+        //     revert MissingTypeRole();
+        // } 
+
+        _registerPool(
+            info.nftId,
+            instanceNftId,
+            instance,
+            data
+        );
+    }
+
+    function registerDistribution(	
+        IBaseComponent distribution
+    ) external returns (NftId nftId) {	
+
+        // TODO some info parameters from component and from register may differ -> getObjectInfo() after registration?
+        (
+            IRegistry.ObjectInfo memory info,
+            bytes memory data
+        ) = getRegistryService().registerDistribution(
+            distribution,
+            msg.sender);	
+
+        NftId instanceNftId = info.parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        IInstance instance = IInstance(instanceAddress);
+
+        RoleId typeRole = getRoleForType(DISTRIBUTION());
+        // TODO refactor to use access manager infra
+        // if(instance.hasRole(typeRole, msg.sender) == false) {
+        //     revert MissingTypeRole();
+        // }
+    }
+
+    function lock(
+        IBaseComponent component
+    ) external override onlyRegisteredComponent(component) {
+        // TODO use msg.sender to get component and get instance via registered parent nft id
+        IInstance instance = component.getInstance();
+        NftId nftId = component.getNftId();
+        Key32 key = nftId.toKey32(COMPONENT());
+        instance.updateState(key, PAUSED());
+    }
+
+    function unlock(
+        IBaseComponent component
+    ) external override onlyRegisteredComponent(component) {
+        // TODO use msg.sender to get component and get instance via registered parent nft id
+        IInstance instance = component.getInstance();
+        NftId nftId = component.getNftId();
+        Key32 key = nftId.toKey32(COMPONENT());
+        instance.updateState(key, ACTIVE());
+    }
+
+    // Internals
+
+    function _registerProduct(
+        NftId nftId, 
+        NftId instanceNftId,
+        IInstance instance,
+        bytes memory data
+    )
+        internal
+    {
+        (
+            ITreasury.TreasuryInfo memory info,
+            address wallet
+        )  = abi.decode(data, (ITreasury.TreasuryInfo, address));
+
+        IRegistry _registry = getRegistry();
+
+        if(wallet == address(0)) {
+            revert WalletIsZero();
+        }
+
+        IRegistry.ObjectInfo memory tokenInfo = _registry.getObjectInfo(address(info.token));
+
+        if(tokenInfo.objectType != TOKEN()) {
+            revert InvalidToken();
+        } 
+
+        IRegistry.ObjectInfo memory poolInfo = _registry.getObjectInfo(info.poolNftId);
+
+        if(poolInfo.objectType != POOL()) {
+            revert InvalidPool();
+        }
+
+        if(poolInfo.parentNftId != instanceNftId) {
+            revert InvalidPoolsInstance();
+        }
+        // TODO pool have the same token
+        //ITreasury.PoolSetup memory poolSetup = instance.getPoolSetup(info.poolNftId);
+        //require(tokenInfo.objectAddress == address(poolSetup.token), "ERROR:COS-018:PRODUCT_POOL_TOKEN_MISMATCH");
+        // TODO pool is not linked
+
+        IRegistry.ObjectInfo memory distributionInfo = _registry.getObjectInfo(info.distributionNftId);
+
+        if(distributionInfo.objectType != DISTRIBUTION()) {
+            revert  InvalidDistribution();
+        } 
+
+        if(distributionInfo.parentNftId != instanceNftId) {
+            revert InvalidDistributionsInstance();
+        }
+        // TODO distribution have the same token
+        // TODO distribution is not linked
+
+        // component module
+        instance.registerComponent(
+            nftId,
+            info.token,
+            wallet // TODO move wallet into TreasuryInfo?
+        );
+
+        // treasury module
+        instance.registerProductSetup(
+            nftId, 
+            info
+        );
+    }
+
+    function _registerPool(
+        NftId nftId,
+        NftId instanceNftId,
+        IInstance instance,
+        bytes memory data
+    )
+        internal
+    {
+        (
+            IPool.PoolInfo memory info,
+            address wallet,
+            IERC20Metadata token,
+            /*poolFee*/,
+            /*stakingFee*/,
+            /*performanceFee*/
+        )  = abi.decode(data, (IPool.PoolInfo, address, IERC20Metadata, Fee, Fee, Fee));
+
+        IRegistry _registry = getRegistry();
+
+        if(wallet == address(0)) {
+            revert WalletIsZero();
+        }
+
+        ObjectType tokenType = _registry.getObjectInfo(address(token)).objectType;
+
+        if(tokenType != TOKEN()) {
+            revert InvalidToken();
+        } 
+
+        if(UFixedLib.eqz(info.collateralizationLevel)) { 
+            revert CollateralizationLevelIsZero();
+        }
+
+        // TODO add more validations
+
+        // component module
+        instance.registerComponent(
+            nftId,
+            token,
+            wallet
+        ); 
+
+        // pool module
+        instance.registerPool(
+            nftId, 
+            info
+        );
+    }
+}

package/contracts/instance/service/DistributionService.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {ITreasury} from "../../instance/module/treasury/ITreasury.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {DISTRIBUTION} from "../../types/ObjectType.sol";
+import {Version, VersionLib} from "../../types/Version.sol";
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {Versionable} from "../../shared/Versionable.sol";
+
+import {IService} from "../base/IService.sol";
+import {ServiceBase} from "../base/ServiceBase.sol";
+import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {IDistributionService} from "./IDistributionService.sol";
+
+contract DistributionService is
+    ComponentServiceBase,
+    IDistributionService
+{
+    string public constant NAME = "DistributionService";
+
+    constructor(
+        address registry,
+        NftId registryNftId,
+        address initialOwner
+    ) ComponentServiceBase(registry, registryNftId, initialOwner)
+    {
+        _registerInterface(type(IDistributionService).interfaceId);
+    }
+
+
+    function getName() public pure override(IService, ServiceBase) returns(string memory name) {
+        return NAME;
+    }
+
+    function setFees(
+        Fee memory distributionFee
+    )
+        external
+        override
+    {
+        (IRegistry.ObjectInfo memory distributionInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
+
+        NftId productNftId = instance.getProductNftId(distributionInfo.nftId);
+        ITreasury.TreasuryInfo memory treasuryInfo = instance.getTreasuryInfo(productNftId);
+        treasuryInfo.distributionFee = distributionFee;
+        instance.setTreasuryInfo(productNftId, treasuryInfo);
+    }
+}

package/contracts/instance/service/IComponentOwnerService.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType} from "../../types/ObjectType.sol";
+import {RoleId} from "../../types/RoleId.sol";
+import {IBaseComponent} from "../../components/IBaseComponent.sol";
+import {IService} from "../base/IService.sol";
+
+// TODO rename to registry service
+interface IComponentOwnerService is IService {
+
+    // TODO move to product/pool services
+    function lock(IBaseComponent component) external;
+
+    // TODO move to product/pool services
+    function unlock(IBaseComponent component) external;
+
+    function getRoleForType(ObjectType cType) external pure returns (RoleId role);
+}

package/contracts/instance/service/IDistributionService.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {IService} from "../base/IService.sol";
+
+interface IDistributionService is IService {
+    function setFees(
+        Fee memory distributionFee
+    ) external;
+}

package/contracts/instance/service/IPoolService.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {IService} from "../base/IService.sol";
+
+interface IPoolService is IService {
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+
+    function createBundle(
+        address owner,
+        Fee memory fee, 
+        uint256 amount,
+        uint256 lifetime, 
+        bytes calldata filter
+    ) external returns(NftId bundleNftId);
+
+    function setBundleFee(
+        NftId bundleNftId,
+        Fee memory fee
+    ) external;
+
+    // function fundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+    // function defundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+    // function lockBundle(NftId bundleNftId) external;
+
+    // function unlockBundle(NftId bundleNftId) external;
+
+    // function closeBundle(NftId bundleNftId) external;
+}

package/contracts/instance/service/IProductService.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRisk} from "../module/risk/IRisk.sol";
+import {IService} from "../base/IService.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {ReferralId} from "../../types/ReferralId.sol";
+import {RiskId} from "../../types/RiskId.sol";
+import {StateId} from "../../types/StateId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {Fee} from "../../types/Fee.sol";
+
+interface IProductService is IService {
+    function setFees(
+        Fee memory productFee,
+        Fee memory processingFee
+    ) external;
+
+    function createRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function setRiskInfo(
+        RiskId riskId,
+        IRisk.RiskInfo memory data
+    ) external;
+
+
+    function updateRiskState(
+        RiskId riskId,
+        StateId state
+    ) external;
+
+
+    function calculatePremium(
+        RiskId riskId,
+        uint256 sumInsuredAmount,
+        uint256 lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        external
+        view
+        returns (
+            uint256 premiumAmount,
+            uint256 productFeeAmount,
+            uint256 poolFeeAmount,
+            uint256 bundleFeeAmount,
+            uint256 distributionFeeAmount
+        );
+
+
+    function createApplication(
+        address applicationOwner,
+        RiskId riskId,
+        uint256 sumInsuredAmount,
+        uint256 lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    ) external returns (NftId nftId);
+
+    /**
+     * @dev revokes the application represented by {policyNftId}.
+     * an application can only be revoked in applied state.
+     * only the application holder may revoke an application.
+     */
+    function revoke(NftId policyNftId) external;
+
+    /**
+     * @dev underwrites the policy represented by {policyNftId}.
+     * optionally collects premiums and activates the policy.
+     * - premium payment is only attempted if requirePremiumPayment is set to true
+     * - activation is only done if activateAt is a non-zero timestamp
+     */
+    function underwrite(
+        NftId policyNftId,
+        bool requirePremiumPayment,
+        Timestamp activateAt
+    ) external;
+
+    // function decline(uint256 nftId) external;
+    // function expire(uint256 nftId) external;
+
+    function collectPremium(NftId policyNftId, Timestamp activateAt) external;
+
+    function activate(NftId policyNftId, Timestamp activateAt) external;
+
+
+    function close(NftId nftId) external;
+
+    // function createClaim(uint256 nftId, uint256 claimAmount) external;
+    // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;
+    // function declineClaim(uint256 nftId, uint256 claimId) external;
+    // function closeClaim(uint256 nftId, uint256 claimId) external;
+
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        uint256 sumInsuredAmount
+    ) external pure returns(uint256 collateralAmount);
+
+}

package/contracts/instance/service/PoolService.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {IBundle} from "../../instance/module/bundle/IBundle.sol";
+import {ITreasury, ITreasuryModule, TokenHandler} from "../../instance/module/treasury/ITreasury.sol";
+
+import {IVersionable} from "../../shared/IVersionable.sol";
+import {Versionable} from "../../shared/Versionable.sol";
+
+import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
+import {POOL, BUNDLE} from "../../types/ObjectType.sol";
+import {Fee} from "../../types/Fee.sol";
+import {Version, VersionLib} from "../../types/Version.sol";
+
+import {IService} from "../base/IService.sol";
+import {ServiceBase} from "../base/ServiceBase.sol";
+import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {IPoolService} from "./IPoolService.sol";
+
+
+contract PoolService is ComponentServiceBase, IPoolService {
+    using NftIdLib for NftId;
+
+    string public constant NAME = "PoolService";
+
+    constructor(
+        address registry,
+        NftId registryNftId,
+        address initialOwner
+    ) ComponentServiceBase(registry, registryNftId, initialOwner)
+    {
+        _registerInterface(type(IPoolService).interfaceId);
+    }
+
+    function getName() public pure override(IService, ServiceBase) returns(string memory name) {
+        return NAME;
+    }
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        external
+        override
+    {
+        (IRegistry.ObjectInfo memory poolInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+
+        NftId productNftId = instance.getProductNftId(poolInfo.nftId);
+        ITreasury.TreasuryInfo memory treasuryInfo = instance.getTreasuryInfo(productNftId);
+        treasuryInfo.poolFee = poolFee;
+        treasuryInfo.stakingFee = stakingFee;
+        treasuryInfo.performanceFee = performanceFee;
+        instance.setTreasuryInfo(productNftId, treasuryInfo);
+    }
+
+    function createBundle(
+        address owner, 
+        Fee memory fee, 
+        uint256 stakingAmount, 
+        uint256 lifetime, 
+        bytes calldata filter
+    )
+        external
+        override
+        returns(NftId bundleNftId)
+    {
+        (IRegistry.ObjectInfo memory info, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+
+        // register bundle with registry
+        NftId poolNftId = info.nftId;
+        bundleNftId = getRegistryService().registerBundle(
+            IRegistry.ObjectInfo(
+                zeroNftId(),
+                poolNftId,
+                BUNDLE(),
+                false, // intercepting property for bundles is defined on pool
+                address(0),
+                owner,
+                ""
+            )
+        );
+
+        // create bundle info in instance
+        instance.createBundleInfo(
+            bundleNftId,
+            poolNftId,
+            fee,
+            stakingAmount,
+            lifetime,
+            filter);
+
+        // add bundle to pool in instance
+        instance.addBundleToPool(
+            bundleNftId,
+            poolNftId,
+            stakingAmount);
+
+        // collect capital
+        _processStakingByTreasury(
+            instance,
+            poolNftId,
+            bundleNftId,
+            stakingAmount);
+
+        // TODO add logging
+    }
+
+    function setBundleFee(
+        NftId bundleNftId,
+        Fee memory fee
+    )
+        external
+        override
+    {
+        (IRegistry.ObjectInfo memory poolInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+        IBundle.BundleInfo memory bundleInfo = instance.getBundleInfo(bundleNftId);
+        require(bundleInfo.poolNftId.gtz(), "ERROR:PLS-010:BUNDLE_UNKNOWN");
+        require(poolInfo.nftId == bundleInfo.poolNftId, "ERROR:PLS-011:BUNDLE_POOL_MISMATCH");
+        bundleInfo.fee = fee;
+        instance.setBundleInfo(bundleNftId, bundleInfo);
+    }
+
+
+    function _processStakingByTreasury(
+        IInstance instance,
+        NftId poolNftId,
+        NftId bundleNftId,
+        uint256 stakingAmount
+    )
+        internal
+    {
+        // process token transfer(s)
+        if(stakingAmount > 0) {
+            NftId productNftId = instance.getProductNftId(poolNftId);
+            TokenHandler tokenHandler = instance.getTokenHandler(productNftId);
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            address poolWallet = instance.getComponentWallet(poolNftId);
+
+            tokenHandler.transfer(
+                bundleOwner,
+                poolWallet,
+                stakingAmount
+            );
+        }
+    }
+}