@etherisc/gif-next 0.0.2-b9b3e89 → 0.0.2-bc11089-288

package/contracts/instance/service/DistributionService.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {InstanceReader} from "../../instance/InstanceReader.sol";
+import {ISetup} from "../../instance/module/ISetup.sol";
+import {ITreasury} from "../../instance/module/ITreasury.sol";
+
+import {NftId, NftIdLib} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {DISTRIBUTION_OWNER_ROLE} from "../../types/RoleId.sol";
+import {KEEP_STATE} from "../../types/StateId.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 "../../shared/IService.sol";
+import {Service} from "../../shared/Service.sol";
+import {ComponentServiceBase} from "../base/ComponentServiceBase.sol";
+import {IDistributionService} from "./IDistributionService.sol";
+import {Distribution} from "../../components/Distribution.sol";
+import {InstanceService} from "../InstanceService.sol";
+import {Instance} from "../Instance.sol";
+import {INftOwnable} from "../../shared/INftOwnable.sol";
+import {IBaseComponent} from "../../components/IBaseComponent.sol";
+
+string constant DISTRIBUTION_SERVICE_NAME = "DistributionService";
+
+contract DistributionService is
+    ComponentServiceBase,
+    IDistributionService
+{
+    using NftIdLib for NftId;
+
+    string public constant NAME = "DistributionService";
+
+    address internal _registryAddress;
+    
+    function _initialize(
+        address owner, 
+        bytes memory data
+    )
+        internal
+        initializer
+        virtual override
+    {
+        address initialOwner;
+        address registryAddress;
+        (registryAddress, initialOwner) = abi.decode(data, (address, address));
+        // TODO while DistributionService is not deployed in DistributionServiceManager constructor
+        //      owner is DistributionServiceManager deployer
+        _initializeService(registryAddress, owner);
+
+        _registerInterface(type(IDistributionService).interfaceId);
+    }
+
+
+    function getName() public pure override(IService, Service) returns(string memory name) {
+        return NAME;
+    }
+
+    function register(address distributionAddress) 
+        external
+        returns(NftId distributionNftId)
+    {
+        address distributionOwner = msg.sender;
+        IBaseComponent distribution = IBaseComponent(distributionAddress);
+
+        IRegistry.ObjectInfo memory info;
+        bytes memory data;
+        (info, data) = getRegistryService().registerDistribution(distribution, distributionOwner);
+
+        IInstance instance = _getInstance(info);
+
+        bool hasRole = getInstanceService().hasRole(
+            distributionOwner, 
+            DISTRIBUTION_OWNER_ROLE(), 
+            address(instance));
+
+        if(!hasRole) {
+            revert ExpectedRoleMissing(DISTRIBUTION_OWNER_ROLE(), distributionOwner);
+        }
+
+        distributionNftId = info.nftId;
+        ISetup.DistributionSetupInfo memory initialSetup = _decodeAndVerifyDistributionSetup(data);
+        instance.createDistributionSetup(distributionNftId, initialSetup);
+    }
+
+    function _decodeAndVerifyDistributionSetup(bytes memory data) internal returns(ISetup.DistributionSetupInfo memory setup)
+    {
+        setup = abi.decode(
+            data,
+            (ISetup.DistributionSetupInfo)
+        );
+
+        // TODO add checks if applicable 
+    }
+
+    function setFees(
+        Fee memory distributionFee
+    )
+        external
+        override
+    {
+        (IRegistry.ObjectInfo memory info , IInstance instance) = _getAndVerifyComponentInfoAndInstance(DISTRIBUTION());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId distributionNftId = info.nftId;
+
+        ISetup.DistributionSetupInfo memory distSetupInfo = instanceReader.getDistributionSetupInfo(distributionNftId);
+        distSetupInfo.distributionFee = distributionFee;
+        
+        instance.updateDistributionSetup(distributionNftId, distSetupInfo, KEEP_STATE());
+    }
+}

package/contracts/instance/service/DistributionServiceManager.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 {DistributionService} from "./DistributionService.sol";
+import {Registry} from "../../registry/Registry.sol";
+import {RegistryService} from "../../registry/RegistryService.sol";
+import {VersionLib} from "../../types/Version.sol";
+
+contract DistributionServiceManager is ProxyManager {
+
+    DistributionService private _distributionService;
+
+    /// @dev initializes proxy manager with distribution service implementation and deploys instance
+    constructor(
+        address registryAddress
+    )
+        ProxyManager()
+    {
+        DistributionService distSrv = new DistributionService();
+        bytes memory data = abi.encode(registryAddress, address(this));
+        IVersionable versionable = deploy(
+            address(distSrv), 
+            data);
+
+        _distributionService = DistributionService(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(_distributionService);
+        
+        // TODO no nft to link yet
+        // link ownership of instance service manager ot nft owner of instance service
+        //_linkToNftOwnable(
+        //    address(registryAddress),
+        //    address(_distributionService));
+
+        // implies that after this constructor call only upgrade functionality is available
+        _isDeployed = true;
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getDistributionService()
+        external
+        view
+        returns (DistributionService distributionService)
+    {
+        return _distributionService;
+    }
+
+}

package/contracts/instance/service/IBundleService.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {StateId} from "../../types/StateId.sol";
+import {IService} from "../../shared/IService.sol";
+import {IBundle} from "../module/IBundle.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+
+interface IBundleService is IService {
+    error ErrorIBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
+
+    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 updateBundle(NftId instanceNftId, NftId bundleNftId, IBundle.BundleInfo memory bundleInfo, StateId state) external;
+
+    function underwritePolicy(IInstance instanceNftId,
+        NftId policyNftId, 
+        NftId bundleNftId, 
+        uint256 collateralAmount,
+        uint256 netPremium
+    ) 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/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 "../../shared/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 "../../shared/IService.sol";
+
+interface IDistributionService is IService {
+    function setFees(
+        Fee memory distributionFee
+    ) external;
+}

package/contracts/instance/service/IPolicyService.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRisk} from "../module/IRisk.sol";
+import {IService} from "../../shared/IService.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {ReferralId} from "../../types/Referral.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 IPolicyService is IService {
+    
+    error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    
+    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; // TODO payoutClaim() -> implicit close when payed out in full
+
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        uint256 sumInsuredAmount
+    ) external pure returns(uint256 collateralAmount);
+
+}

package/contracts/instance/service/IPoolService.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {StateId} from "../../types/StateId.sol";
+import {IService} from "../../shared/IService.sol";
+import {IBundle} from "../module/IBundle.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+
+interface IPoolService is IService {
+
+    function register(address poolAddress) external returns(NftId);
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+}

package/contracts/instance/service/IProductService.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRisk} from "../module/IRisk.sol";
+import {IService} from "../../shared/IService.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {ReferralId} from "../../types/Referral.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 register(address productAddress) external returns(NftId);
+
+    function setFees(
+        Fee memory productFee,
+        Fee memory processingFee
+    ) external;
+
+    function createRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRiskState(
+        RiskId riskId,
+        StateId newState
+    ) external;
+}