@etherisc/gif-next 0.0.2-e1e92ab-754 → 0.0.2-e26c262-698

package/contracts/components/IDistributionComponent.sol

@@ -2,44 +2,69 @@
 pragma solidity ^0.8.19;
 
 import {Fee} from "../types/Fee.sol";
-import {ReferralId} from "../types/ReferralId.sol";
+import {IComponent} from "./IComponent.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
+import {ReferralId, ReferralStatus} from "../types/Referral.sol";
 import {NftId} from "../types/NftId.sol";
+import {DistributorType} from "../types/DistributorType.sol";
+import {UFixed} from "../types/UFixed.sol";
+import {Timestamp} from "../types/Timestamp.sol";
 
-interface IDistributionComponent {
+interface IDistributionComponent is IComponent {
+
+    event LogDistributorUpdated(address to, address caller);
+
+    function getSetupInfo() external view returns (ISetup.DistributionSetupInfo memory setupInfo);
 
     function setFees(
+        Fee memory minDistributionOwnerFee,
         Fee memory distributionFee
     ) external;
 
-    function calculateFeeAmount(
-        ReferralId referralId,
-        uint256 netPremiumAmount
-    ) external view returns (uint256 feeAmount);
+    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);
+
+    function updateDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    ) external;
 
     function calculateRenewalFeeAmount(
         ReferralId referralId,
         uint256 netPremiumAmount
     ) external view returns (uint256 feeAmount);
 
-    /// @dev callback from product service when selling a policy for a specific referralId
-    /// the used referral id and the collected fee are provided as parameters
-    /// the component implementation can then process this information accordingly
-    function processSale(
-        ReferralId referralId,
-        uint256 feeAmount
-    ) external;
-
     /// @dev callback from product service when a policy is renews for a specific referralId
     function processRenewal(
         ReferralId referralId,
         uint256 feeAmount
     ) external;
 
-    /// @dev returns true iff the referral id is valid
-    function referralIsValid(ReferralId referralId) external view returns (bool isValid);
+    function getDiscountPercentage(
+        string memory referralCode
+    ) external view returns (UFixed discountPercentage, ReferralStatus status);
+
+    function getDistributionFee() external view returns (Fee memory distibutionFee);
 
-    /// @dev default distribution fee, ie when not using any valid referralId
-    function getDistributionFee() external view returns (Fee memory distributionFee);
+    function getReferralId(
+        string memory referralCode
+    ) external returns (ReferralId referralId);
 
     /// @dev returns true iff the component needs to be called when selling/renewing policis
     function isVerifying() external view returns (bool verifying);

package/contracts/components/IPoolComponent.sol

@@ -1,64 +1,113 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../types/NftId.sol";
 import {Fee} from "../types/Fee.sol";
+import {IComponent} from "./IComponent.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {NftId} from "../types/NftId.sol";
+import {RoleId} from "../types/RoleId.sol";
+import {Seconds} from "../types/Seconds.sol";
 import {UFixed} from "../types/UFixed.sol";
 
-interface IPoolComponent {
+/// @dev pool components hold and manage the collateral to cover active policies
+/// pools come in different flavors
+interface IPoolComponent is IComponent {
 
-    event LogUnderwrittenByPool(NftId policyNftId, uint256 collateralizationAmount, address pool);
+    error ErrorPoolNotBundleOwner(NftId bundleNftId, address caller);
+    error ErrorPoolNotPoolService(address caller);
 
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    ) external;
+    error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
+
+    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, uint256 collateralizationAmount);
+
+    /// @dev increases the staked tokens by the specified amount
+    /// only the bundle owner may stake tokens
+    /// bundle MUST be in active or locked state
+    function stake(NftId bundleNftId, uint256 amount) external;
+
+    /// @dev decreases the staked tokens by the specified amount
+    /// only the bundle owner may unstake tokens from the bundle
+    /// bundle MUST be in active, locked or closed state
+    function unstake(NftId bundleNftId, uint256 amount) external;
+
+    /// @dev extends the bundle lifetime of the bundle by the specified time
+    /// only the bundle owner may extend the bundle's lifetime
+    /// bundle MUST be in active or locked state
+    function extend(NftId bundleNftId, Seconds lifetimeExtension) external;
+
+    /// @dev locks the specified bundle
+    /// a bundle to be locked MUST be in active state
+    /// locked bundles may not be used to underwrite any new policy
+    function lockBundle(NftId bundleNftId) external;
+
+    /// @dev unlocks the specified bundle
+    /// a bundle to be unlocked MUST be in locked state
+    function unlockBundle(NftId bundleNftId) external;
 
-    /**
-     * @dev creates a new bundle for this pool.
-     */
-    function createBundle(
-        Fee memory fee,
-        uint256 initialAmount,
-        uint256 lifetime,
-        bytes memory filter
-    ) external returns(NftId bundleNftId);
+    /// @dev close the specified bundle
+    /// a bundle to be closed MUST be in active or locked state
+    /// to close a bundle all all linked policies MUST be in closed state as well
+    /// closing a bundle finalizes the bundle bookkeeping including overall profit calculation
+    /// once a bundle is closed this action cannot be reversed
+    function close(NftId bundleNftId) external;
 
+    /// @dev sets the fee for the specified bundle
+    /// the fee is added on top of the poolFee and deducted from the premium amounts
+    /// via these fees individual bundler owner may earn income per policy in the context of peer to peer pools
     function setBundleFee(
-        NftId policyNftId, 
+        NftId bundleNftId, 
         Fee memory fee
     ) external;
 
-    /** 
-     * @dev this is a callback function that is called by the product service when underwriting a policy.
-     * the pool has the option to check the details and object to underwriting by reverting.
-     * the function is only called for "active" pools that ask to be involved/notified
-     * by product related state changes.
-     */
-    function underwrite(
-        NftId policyNftId, 
-        bytes memory policyData,
+    /// @dev sets the maximum overall capital amound held by this pool
+    /// function may only be called by pool owner
+    function setMaxCapitalAmount(uint256 maxCapitalAmount) external;
+
+    /// @dev sets the required role to create/own bundles
+    /// may only be called once after setting up a pool
+    /// may only be called by pool owner 
+    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
+
+    /// @dev update pool fees to the specified values
+    /// pool fees: are deducted from the premium amount and goes to the pool owner
+    /// staking fees: are deducted from the staked tokens by a bundle owner and goes to the pool owner
+    /// performance fees: when a bundle is closed a bundle specific profit is calculated
+    /// the performance fee is deducted from this profit and goes to the pool owner
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+
+    /// @dev this is a callback function that is called by the product service when underwriting a policy.
+    /// the pool has the option to check the details and object to underwriting by reverting.
+    /// the function is only called for "active" pools that ask to be involved/notified
+    /// by product related state changes.
+    function verifyApplication(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
         bytes memory bundleFilter,
         uint256 collateralizationAmount
     ) external;
 
-    /**
-     * @dev returns true iff the policy application data in policyData matches
-     * with the bundle filter criteria encoded in bundleFilter. 
-     */
-    function policyMatchesBundle(
-        bytes memory policyData,
-        bytes memory bundleFilter
+    /// @dev returns true iff the application matches with the bundle 
+    /// this is a callback function that is only called if a pool declares itself as a verifying pool
+    /// default implementation returns true
+    function applicationMatchesBundle(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        uint256 collateralizationAmount
     )
         external
         view
         returns (bool isMatching);
 
-    function isVerifying() external view returns (bool verifying);
-
-    function getCollateralizationLevel() external view returns (UFixed collateralizationLevel);
-
-    function getFees() external view returns (Fee memory poolFee, Fee memory stakingFee, Fee memory performanceFee);
+    /// @dev returns pool specific infos for this pool
+    /// when registered with an instance the info is obtained from the data stored in the instance
+    /// when not registered the function returns the info from the component contract
+    function getPoolInfo() external view returns (IComponents.PoolInfo memory info);
 
 }

package/contracts/components/IProductComponent.sol

@@ -2,11 +2,16 @@
 pragma solidity ^0.8.20;
 
 import {Fee} from "../types/Fee.sol";
+import {IComponent} from "./IComponent.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
 import {NftId} from "../types/NftId.sol";
-import {ReferralId} from "../types/ReferralId.sol";
+import {ReferralId} from "../types/Referral.sol";
 import {RiskId} from "../types/RiskId.sol";
+import {Seconds} from "../types/Seconds.sol";
 
-interface IProductComponent {
+interface IProductComponent is IComponent {
+
+    function getSetupInfo() external view returns (ISetup.ProductSetupInfo memory setupInfo);
 
     function setFees(
         Fee memory productFee,
@@ -16,22 +21,20 @@ interface IProductComponent {
     function calculatePremium(
         uint256 sumInsuredAmount,
         RiskId riskId,
-        uint256 lifetime,
+        Seconds lifetime,
         bytes memory applicationData,
-        ReferralId referralId,
-        NftId bundleNftId
+        NftId bundleNftId,
+        ReferralId referralId
     ) external view returns (uint256 premiumAmount);
 
     function calculateNetPremium(
         uint256 sumInsuredAmount,
         RiskId riskId,
-        uint256 lifetime,
+        Seconds lifetime,
         bytes memory applicationData
     ) external view returns (uint256 netPremiumAmount);    
 
-    function getProductFee() external view returns (Fee memory productFee);
-    function getProcessingFee() external view returns (Fee memory processingFee);
-
+    
     function getPoolNftId() external view returns (NftId poolNftId);
     function getDistributionNftId() external view returns (NftId distributionNftId);
 }