@etherisc/gif-next 0.0.2-d96b9e1-825 → 0.0.2-da09ec0-359

package/contracts/instance/service/IDistributionService.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Amount} from "../../types/Amount.sol";
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {IPolicy} from "../module/IPolicy.sol";
+import {IService} from "../../shared/IService.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {DistributorType} from "../../types/DistributorType.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+
+
+interface IDistributionService is IService {
+    error ErrorDistributionServiceCallerNotRegistered(address caller);
+    error ErrorIDistributionServiceParentNftIdNotInstance(NftId nftId, NftId parentNftId);
+    error ErrorIDistributionServiceCallerNotDistributor(address caller);
+    error ErrorIDistributionServiceInvalidReferralId(ReferralId referralId);
+    error ErrorIDistributionServiceMaxReferralsExceeded(uint256 maxReferrals);
+    error ErrorIDistributionServiceDiscountTooLow(uint256 minDiscountPercentage, uint256 discountPercentage);
+    error ErrorIDistributionServiceDiscountTooHigh(uint256 maxDiscountPercentage, uint256 discountPercentage);
+    error ErrorIDistributionServiceExpiryTooLong(uint256 maxReferralLifetime, uint256 expiryAt);
+    error ErrorIDistributionServiceInvalidReferral(string code);
+    error ErrorIDistributionServiceExpirationInvalid(Timestamp expiryAt);
+    error ErrorIDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
+    error ErrorIDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
+    error ErrorIDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
+    error ErrorIDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
+    error ErrorDistributionServiceInvalidFeeTransferred(Amount transferredDistributionFeeAmount, Amount expectedDistributionFeeAmount);
+
+    function setFees(
+        Fee memory minDistributionOwnerFee,
+        Fee memory distributionFee
+    ) external;
+    
+    function createDistributorType(
+        string memory name,
+        UFixed minDiscountPercentage,
+        UFixed maxDiscountPercentage,
+        UFixed commissionPercentage,
+        uint32 maxReferralCount,
+        uint32 maxReferralLifetime,
+        bool allowSelfReferrals,
+        bool allowRenewals,
+        bytes memory data
+    )
+        external
+        returns (DistributorType distributorType);
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    ) external returns (NftId distributorNftId);
+
+    // TODO re-enable and reorganize (service contract too large)
+    // function updateDistributorType(
+    //     NftId distributorNftId,
+    //     DistributorType distributorType,
+    //     bytes memory data
+    // ) external;
+
+    function createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        external
+        returns (ReferralId referralId);
+
+    /// @dev callback from product service when selling a policy for a specific referralId
+    function processSale(
+        NftId distributionNftId,
+        ReferralId referralId,
+        IPolicy.Premium memory premium,
+        Amount transferredDistributionFeeAmount
+    ) external;
+
+    function referralIsValid(
+        NftId distributorNftId,
+        ReferralId referralId
+    ) external view returns (bool isValid);
+}

package/contracts/instance/service/IPolicyService.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRisk} from "../module/IRisk.sol";
+import {IService} from "../../shared/IService.sol";
+
+import {Amount} from "../../types/Amount.sol";
+import {ClaimId} from "../../types/ClaimId.sol";
+import {NftId} from "../../types/NftId.sol";
+import {PayoutId} from "../../types/PayoutId.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {RiskId} from "../../types/RiskId.sol";
+import {Seconds} from "../../types/Seconds.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 ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
+    error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
+
+    error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId, Amount premiumPaidAmount);
+    error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorIPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+    error ErrorIPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
+    error ErrorPolicyServicePremiumNotFullyPaid(NftId policyNftId, Amount premiumAmount, Amount premiumPaidAmount);
+    error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
+    error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
+
+    error ErrorPolicyServicePremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount recalculatedPremiumAmount);
+    error ErrorPolicyServiceTransferredPremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount transferredPremiumAmount);
+
+    /// @dev collateralizes the policy represented by {policyNftId}
+    /// sets the policy state to collateralized
+    /// may set the policy state to activated and set the activation date
+    /// 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
+    /// an application can only be collateralized in applied state
+    /// only the related product may collateralize an application
+    function collateralize(
+        NftId policyNftId,
+        bool requirePremiumPayment,
+        Timestamp activateAt
+    ) external;
+
+    /// @dev declines an application represented by {policyNftId}
+    /// an application can only be declined in applied state
+    /// only the related product may decline an application
+    function decline(NftId policyNftId) external;
+
+    /// @dev collects the premium token for the specified policy
+    function collectPremium(NftId policyNftId, Timestamp activateAt) external;
+
+    /// @dev activates the specified policy and sets the activation date in the policy metadata
+    /// to activate a policy it needs to be in underwritten state
+    function activate(NftId policyNftId, Timestamp activateAt) external;
+
+    /// @dev expires the specified policy and sets the expiry date in the policy metadata
+    /// to expire a policy it must be in active state, policies may be expired even when the predefined expiry date is still in the future
+    /// a policy can only be closed when it has been expired. in addition, it must not have any open claims
+    /// this function can only be called by a product. the policy needs to match with the calling product
+    function expire(NftId policyNftId) external;
+
+    /// @dev closes the specified policy and sets the closed data in the policy metadata
+    /// a policy can only be closed when it has been expired. in addition, it must not have any open claims
+    /// this function can only be called by a product. the policy needs to match with the calling product
+    function close(NftId policyNftId) external;
+
+
+    // TODO move function to pool service
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        Amount sumInsuredAmount
+    ) external pure returns(Amount collateralAmount);
+
+}

package/contracts/instance/service/IPoolService.sol

@@ -1,30 +1,114 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {NftId} from "../../types/NftId.sol";
+import {Amount} from "../../types/Amount.sol";
 import {Fee} from "../../types/Fee.sol";
-import {IService} from "../base/IService.sol";
+import {NftId} from "../../types/NftId.sol";
+import {PayoutId} from "../../types/PayoutId.sol";
+import {IBundle} from "../module/IBundle.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {IPolicy} from "../module/IPolicy.sol";
+import {IService} from "../../shared/IService.sol";
+import {RoleId} from "../../types/RoleId.sol";
+import {Seconds} from "../../types/Seconds.sol";
+import {StateId} from "../../types/StateId.sol";
 
 interface IPoolService is IService {
+
+    event LogPoolServiceMaxCapitalAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
+    event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
+
+    event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+    event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+
+    error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
+    error ErrorPoolServiceBundlePoolMismatch(NftId bundlePoolNftId, NftId productPoolNftId);
+    error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
+
+    /// @dev registers a new pool with the registry service
+    function register(address poolAddress) external returns(NftId);
+
+    /// @dev defines the required role for bundle owners for the calling pool
+    /// default implementation returns PUBLIC ROLE
+    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
+
+    /// @dev sets the max capital amount for the calling pool
+    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
+
+    /// @dev set pool sepecific fees
     function setFees(
+        Fee memory poolFee,
         Fee memory stakingFee,
         Fee memory performanceFee
     ) external;
 
+
+    /// @dev locks required collateral to cover the specified application (and turn it into a policy)
+    /// - retention level == 1: the full collateral amount will be locked by the specified bundle
+    /// - retention level < 1: a part of the coverage is provided by the specified bundle, the rest by the pool component
+    /// in which case the pool component might hold a re-insurance policy
+    /// may only be called by the policy service for unlocked pool components
+    function lockCollateral(
+        IInstance instance, 
+        NftId productNftId,
+        NftId applicationNftId,
+        IPolicy.PolicyInfo memory applicationInfo,
+        Amount premiumAmount
+    ) external;
+
+
+    /// @dev releases the remaining collateral linked to the specified policy
+    /// may only be called by the policy service for unlocked pool components
+    function releaseCollateral(
+        IInstance instance, 
+        NftId policyNftId, 
+        IPolicy.PolicyInfo memory policyInfo
+    ) external;
+
+
+    /// @dev reduces the locked collateral in the bundle associated with the specified policy
+    /// every payout of a policy reduces the collateral by the payout amount
+    /// may only be called by the claim service for unlocked pool components
+    function reduceCollateral(
+        IInstance instance, 
+        NftId policyNftId, 
+        IPolicy.PolicyInfo memory policyInfo,
+        Amount payoutAmount
+    ) external;
+
+
+    /// @dev create a new bundle for the provided parameters
+    /// staking fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
     function createBundle(
-        address owner,
-        uint256 amount,
-        uint256 lifetime, 
-        bytes calldata filter
-    ) external returns(NftId bundleNftId);
+        address owner, // initial bundle owner
+        Fee memory fee, // fees deducted from premium that go to bundle owner
+        Amount stakingAmount, // staking amount - staking fees result in initial bundle capital
+        Seconds lifetime, // initial duration for which new policies are covered
+        bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
+    )
+        external 
+        returns(NftId bundleNftId); // the nft id of the newly created bundle
+
 
-    // function fundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    /// @dev closes the specified bundle
+    /// only open bundles (active or locked) may be closed
+    /// to close a bundle it may not have any non-closed polices attached to it
+    /// bundle fees and remaining capital (after deduction of the performance fee) will be transferred to the bundle owner
+    /// may only be called by registered and unlocked pool components
+    function closeBundle(NftId bundleNftId) external;
 
-    // function defundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    /// @dev processes the sale of a bundle and track the pool fee and bundle fee amounts
+    function processSale(NftId bundleNftId, IPolicy.Premium memory premium, Amount actualAmountTransferred) external;
 
-    // function lockBundle(NftId bundleNftId) external;
+    /// @dev increase stakes for bundle
+    /// staking fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
+    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 
-    // function unlockBundle(NftId bundleNftId) external;
 
-    // function closeBundle(NftId bundleNftId) external;
+    /// @dev decrease stakes for bundle
+    /// performance fees will be deducted by the pool service from the staking amount
+    /// may only be called by registered and unlocked pool components
+    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 }

package/contracts/instance/service/IPricingService.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Seconds} from "../../types/Seconds.sol";
+import {NftId} from "../../types/NftId.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {RiskId} from "../../types/RiskId.sol";
+import {Amount} from "../../types/Amount.sol";
+
+import {IService} from "./IApplicationService.sol";
+import {IPolicy} from "../module/IPolicy.sol";
+
+interface IPricingService is IService
+{
+    error ErrorIPricingServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
+    error ErrorIPricingServiceFeeCalculationMismatch(
+                uint256 distributionFeeFixAmount,
+                uint256 distributionFeeVarAmount,
+                uint256 distributionOwnerFeeFixAmount,
+                uint256 distributionOwnerFeeVarAmount,
+                uint256 commissionAmount,
+                uint256 discountAmount
+            );
+
+    function calculatePremium(
+        NftId productNftId,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        external
+        view
+        returns (IPolicy.Premium memory premium);
+}

package/contracts/instance/service/IProductService.sol

@@ -1,58 +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";
-import {IService} from "../base/IService.sol";
 
 interface IProductService is IService {
+    
+    function register(address productAddress) external returns(NftId);
+
     function setFees(
-        Fee memory policyFee,
+        Fee memory productFee,
         Fee memory processingFee
     ) external;
 
-    function createApplication(
-        address applicationOwner,
-        uint256 sumInsuredAmount,
-        uint256 premiumAmount,
-        uint256 lifetime,
-        NftId bundleNftId
-    ) external returns (NftId nftId);
-
-    // function revoke(unit256 nftId) 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
+    function createRisk(
+        RiskId riskId,
+        bytes memory data
     ) external;
 
-    // function decline(uint256 nftId) external;
-    // function expire(uint256 nftId) external;
-
-    function collectPremium(NftId nftId, Timestamp activateAt) external;
-
-    function activate(NftId nftId, Timestamp activateAt) external;
 
+    function updateRisk(
+        RiskId riskId,
+        bytes memory data
+    ) 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);
 
+    function updateRiskState(
+        RiskId riskId,
+        StateId newState
+    ) external;
 }