@etherisc/gif-next 0.0.2-91f98cf-477 → 0.0.2-93de5de-423

package/contracts/components/IDistributionComponent.sol

@@ -2,16 +2,62 @@
 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 {IBaseComponent} from "./IBaseComponent.sol";
+import {DistributorType} from "../types/DistributorType.sol";
+import {UFixed} from "../types/UFixed.sol";
+import {Timestamp} from "../types/Timestamp.sol";
 
-interface IDistributionComponent is IBaseComponent {
+interface IDistributionComponent is IComponent {
+
+    event LogDistributorUpdated(address to, address caller);
+
+    function getSetupInfo() external view returns (ISetup.DistributionSetupInfo memory setupInfo);
 
     function setFees(
         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);
+
+    function updateDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    ) external;
+
+    /**
+     * @dev lets distributors create referral codes.
+     * referral codes need to be unique
+     * distributor is identified via msg.sender.
+     */
+    function createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    ) external returns (ReferralId referralId);
+
     function calculateFeeAmount(
         ReferralId referralId,
         uint256 netPremiumAmount
@@ -36,12 +82,19 @@ interface IDistributionComponent is IBaseComponent {
         uint256 feeAmount
     ) external;
 
+    function getDiscountPercentage(
+        string memory referralCode
+    ) external view returns (UFixed discountPercentage, ReferralStatus status);
+
+    function getDistributionFee() external view returns (Fee memory distibutionFee);
+
+    function getReferralId(
+        string memory referralCode
+    ) external returns (ReferralId referralId);
+
     /// @dev returns true iff the referral id is valid
     function referralIsValid(ReferralId referralId) external view returns (bool isValid);
 
-    /// @dev default distribution fee, ie when not using any valid referralId
-    function getDistributionFee() external view returns (Fee memory distributionFee);
-
     /// @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,71 +1,87 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {NftId} from "../types/NftId.sol";
 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 {UFixed} from "../types/UFixed.sol";
-import {IBaseComponent} from "./IBaseComponent.sol";
 
-interface IPoolComponent is IBaseComponent {
+/// @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 ErrorPoolNotPoolService(address service);
+
+    function getSetupInfo() external view returns (ISetup.PoolSetupInfo memory setupInfo);
+
     function setFees(
         Fee memory poolFee,
         Fee memory stakingFee,
         Fee memory performanceFee
     ) 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 sets an additional bundle fee, this 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, 
+    /// @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 policyData,
         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
-    )
-        external
-        view
-        returns (bool isMatching);
+    function lockBundle(NftId bundleNftId) external;
 
-    function isVerifying() external view returns (bool verifying);
+    function unlockBundle(NftId bundleNftId) external;
 
+    /// @dev defines the multiplier to calculate the required collateral to cover a given sum insured amount
+    /// default implementation returns 100%
     function getCollateralizationLevel() external view returns (UFixed collateralizationLevel);
 
-    function getPoolFee() external view returns (Fee memory poolFee);
+    /// @dev defines the amount of collateral held in the pool.
+    /// if the value is < 100% the pool is required to hold a policy that covers the locally missing collateral
+    /// default implementation returns 100%
+    function getRetentionLevel() external view returns (UFixed retentionLevel);
+
+    /// @dev declares if pool intercept transfers of bundle nft ids
+    /// - yes: pool may block transfer of bundle ownership or simply updates some bookkeeping related to bundle ownership. callback function is nftTransferFrom
+    /// - no: pool is not involved in transfer of bundle ownership
+    /// default implementation returns false (no)
+    function isInterceptingBundleTransfers() external view returns (bool);
 
-    function getStakingFee() external view returns (Fee memory stakingFee);
+    /// @dev declares if pool relies on external management of collateral (yes/no): 
+    /// - yes: underwriting of new policies does not require an actual token balance, instead it is assumed that the pool owner will manage funds externally and inject enough tokens to allow process confirmed payouts
+    /// - no: the pool smart contract ensures that the necessary capacity of the pool prior to underwriting.
+    /// default implementation returns false (no)
+    function isExternallyManaged() external view returns (bool);
 
-    function getPerformanceFee()
+    /// @dev declares if pool component is actively involved in underwriting (yes/no): 
+    /// - yes: verifying pools components actively confirm underwriting applications, ie the pool component logic explicitly needs to confirm the locking of collateral to cover the sum insured of the policy
+    /// - no: underwriting a policy does not require any interaction with the pool component if the covering bundle can provide the necessary captial
+    /// default implementation returnsfalse (no)
+    function isVerifyingApplications() external view returns (bool);
+
+    /// @dev returns true iff the policy application data in policyData matches
+    /// with the bundle filter criteria encoded in bundleFilter
+    /// this is a callback function that is only called if a pool declares itself as a verifying pool
+    /// default implementation returns true
+    function policyMatchesBundle(
+        bytes memory policyData,
+        bytes memory bundleFilter
+    )
         external
         view
-        returns (Fee memory performanceFee);
+        returns (bool isMatching);
+
 }

package/contracts/components/IProductComponent.sol

@@ -1,14 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+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 {IBaseComponent} from "./IBaseComponent.sol";
+interface IProductComponent is IComponent {
+
+    function getSetupInfo() external view returns (ISetup.ProductSetupInfo memory setupInfo);
 
-interface IProductComponent is IBaseComponent {
     function setFees(
         Fee memory productFee,
         Fee memory processingFee
@@ -19,8 +22,8 @@ interface IProductComponent is IBaseComponent {
         RiskId riskId,
         uint256 lifetime,
         bytes memory applicationData,
-        ReferralId referralId,
-        NftId bundleNftId
+        NftId bundleNftId,
+        ReferralId referralId
     ) external view returns (uint256 premiumAmount);
 
     function calculateNetPremium(
@@ -30,9 +33,7 @@ interface IProductComponent is IBaseComponent {
         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);
 }

package/contracts/components/Pool.sol

@@ -1,100 +1,165 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {ObjectType, POOL} from "../types/ObjectType.sol";
-import {IProductService} from "../instance/service/IProductService.sol";
+import {POOL} from "../types/ObjectType.sol";
 import {IPoolService} from "../instance/service/IPoolService.sol";
-import {NftId} from "../types/NftId.sol";
-import {Fee} from "../types/Fee.sol";
+import {IBundleService} from "../instance/service/IBundleService.sol";
+import {NftId, NftIdLib} from "../types/NftId.sol";
+import {Fee, FeeLib} from "../types/Fee.sol";
 import {UFixed} from "../types/UFixed.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
-import {BaseComponent} from "./BaseComponent.sol";
+import {Component} from "./Component.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
 
-contract Pool is BaseComponent, IPoolComponent {
+import {ISetup} from "../instance/module/ISetup.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
 
-    bool internal _isVerifying;
-    UFixed internal _collateralizationLevel;
 
-    Fee internal _initialPoolFee;
-    Fee internal _initialStakingFee;
-    Fee internal _initialPerformanceFee;
+abstract contract Pool is
+    Component, 
+    IPoolComponent 
+{
+    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.Pool")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant POOL_STORAGE_LOCATION_V1 = 0x25e3e51823fbfffb988e0a2744bb93722d9f3e906c07cc0a9e77884c46c58300;
 
-    // may be used to interact with instance by derived contracts
-    IPoolService internal _poolService;
+    struct PoolStorage {
+        UFixed _collateralizationLevel;
+        UFixed _retentionLevel;
 
-    // only relevant to protect callback functions for "active" pools
-    IProductService private _productService;
+        bool _isExternallyManaged;
+        bool _isInterceptingBundleTransfers;
+        bool _isVerifyingApplications;
 
-    modifier onlyPoolService() {
-        require(
-            msg.sender == address(_poolService), 
-            "ERROR:POL-001:NOT_POOL_SERVICE");
-        _;
+        Fee _initialPoolFee;
+        Fee _initialStakingFee;
+        Fee _initialPerformanceFee;
+
+        TokenHandler _tokenHandler;
+
+        // may be used to interact with instance by derived contracts
+        IPoolService _poolService;
+        IBundleService _bundleService;
     }
 
-    modifier onlyProductService() {
-        require(
-            msg.sender == address(_productService), 
-            "ERROR:POL-002:NOT_PRODUCT_SERVICE");
+    modifier onlyPoolService() {
+        if(msg.sender != address(_getPoolStorage()._poolService)) {
+            revert ErrorPoolNotPoolService(msg.sender);
+        }
         _;
     }
 
-    constructor(
+
+    function initializePool(
         address registry,
         NftId instanceNftId,
+        string memory name,
         // TODO refactor into tokenNftId
         address token,
-        bool verifying,
+        bool isInterceptingNftTransfers,
+        bool isExternallyManaging,
+        bool isVerifying,
         UFixed collateralizationLevel,
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
+        UFixed retentionLevel,
+        address initialOwner,
+        bytes memory data
     )
-        BaseComponent(registry, instanceNftId, token)
+        public
+        virtual
+        onlyInitializing()
     {
-        _isVerifying = verifying;
+        initializeComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, data);
+
+        PoolStorage storage $ = _getPoolStorage();
         // TODO add validation
-        _collateralizationLevel = collateralizationLevel;
-        _initialPoolFee = poolFee;
-        _initialStakingFee = stakingFee;
-        _initialPerformanceFee = performanceFee;
+        $._tokenHandler = new TokenHandler(token);
+        $._isExternallyManaged = isExternallyManaging;
+        $._isVerifyingApplications = isVerifying;
+        $._collateralizationLevel = collateralizationLevel;
+        $._retentionLevel = retentionLevel;
+        $._initialPoolFee = FeeLib.zeroFee();
+        $._initialStakingFee = FeeLib.zeroFee();
+        $._initialPerformanceFee = FeeLib.zeroFee();
+        $._poolService = getInstance().getPoolService();
+        $._bundleService = getInstance().getBundleService();
 
-        _poolService = _instance.getPoolService();
-        _productService = _instance.getProductService();
+        registerInterface(type(IPoolComponent).interfaceId);
     }
 
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
+    /**
+     * @dev see {IPool.verifyApplication}. 
+     * Default implementation that only writes a {LogUnderwrittenByPool} entry.
+     */
+    function verifyApplication(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        bytes memory bundleFilter,
+        uint256 collateralizationAmount
     )
         external
-        onlyOwner
-        override
+        restricted()
+        virtual override 
     {
-        _poolService.setFees(poolFee, stakingFee, performanceFee);
+        require(
+            policyMatchesBundle(applicationData, bundleFilter),
+            "ERROR:POL-020:POLICY_BUNDLE_MISMATCH"
+        );
+
+        emit LogUnderwrittenByPool(applicationNftId, collateralizationAmount, address(this));
     }
 
-    function createBundle(
-        Fee memory fee,
-        uint256 initialAmount,
-        uint256 lifetime,
-        bytes memory filter
+
+    function isInterceptingBundleTransfers() external view override returns (bool) {
+        return isNftInterceptor();
+    }
+
+
+    function isExternallyManaged() external view override returns (bool) {
+        return _getPoolStorage()._isExternallyManaged;
+    }
+
+
+    function getRetentionLevel() external view override returns (UFixed retentionLevel) {
+        return _getPoolStorage()._retentionLevel;
+    }
+
+
+    function getCollateralizationLevel() external view override returns (UFixed collateralizationLevel) {
+        return _getPoolStorage()._collateralizationLevel;
+    }
+
+
+    function isVerifyingApplications() external view override returns (bool isConfirmingApplication) {
+        return _getPoolStorage()._isVerifyingApplications;
+    }
+
+
+    /// @dev see {IPoolComponent.policyMatchesBundle}. 
+    /// Default implementation always returns true
+    function policyMatchesBundle(
+        bytes memory, // policyData
+        bytes memory // bundleFilter
     )
-        external
+        public
+        pure
         virtual override
-        returns(NftId bundleNftId)
+        returns (bool isMatching)
     {
-        address owner = msg.sender;
-        bundleNftId = _poolService.createBundle(
-            owner,
-            fee,
-            initialAmount,
-            lifetime,
-            filter
-        );
+        return true;
+    }
 
-        // TODO add logging
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        external
+        onlyOwner
+        restricted()
+        override
+    {
+        _getPoolStorage()._poolService.setFees(poolFee, stakingFee, performanceFee);
     }
 
     function setBundleFee(
@@ -105,131 +170,85 @@ contract Pool is BaseComponent, IPoolComponent {
         override
         // TODO add onlyBundleOwner
     {
-        _poolService.setBundleFee(bundleNftId, fee);
+        _getPoolStorage()._bundleService.setBundleFee(bundleNftId, fee);
     }
 
-    /**
-     * @dev see {IPool.underwrite}. 
-     * Default implementation that only writes a {LogUnderwrittenByPool} entry.
-     */
-    function underwrite(
-        NftId policyNftId, 
-        bytes memory policyData,
-        bytes memory bundleFilter,
-        uint256 collateralizationAmount
+    function lockBundle(
+        NftId bundleNftId
     )
         external
-        onlyProductService
-        virtual override 
+        override
+        // TODO add onlyBundleOwner
     {
-        _underwrite(policyNftId, policyData, bundleFilter, collateralizationAmount);
+        _getPoolStorage()._bundleService.lockBundle(bundleNftId);
     }
 
-    /**
-     * @dev see {IPoolComponent.policyMatchesBundle}. 
-     * Default implementation always returns true
-     */
-    function policyMatchesBundle(
-        bytes memory, // policyData
-        bytes memory // bundleFilter
+    function unlockBundle(
+        NftId bundleNftId
     )
-        public
-        view
-        virtual override
-        returns (bool isMatching)
+        external
+        override
+        // TODO add onlyBundleOwner
     {
-        return true;
+        _getPoolStorage()._bundleService.unlockBundle(bundleNftId);
     }
 
+    function getSetupInfo() public view returns (ISetup.PoolSetupInfo memory setupInfo) {
+        InstanceReader reader = getInstance().getInstanceReader();
+        setupInfo = reader.getPoolSetupInfo(getNftId());
 
-    function isVerifying() external view override returns (bool verifying) {
-        return _isVerifying;
-    }
-
-    function getCollateralizationLevel() external view override returns (UFixed collateralizationLevel) {
-        return _collateralizationLevel;
+        // fallback to initial setup info (wallet is always != address(0))
+        if(setupInfo.wallet == address(0)) {
+            setupInfo = _getInitialSetupInfo();
+        }
     }
 
-    function _underwrite(
-        NftId policyNftId, 
-        bytes memory policyData,
-        bytes memory bundleFilter,
-        uint256 collateralizationAmount
-    )
-        internal 
-    {
-        require(
-            policyMatchesBundle(policyData, bundleFilter),
-            "ERROR:POL-020:POLICY_BUNDLE_MISMATCH"
+    function _getInitialSetupInfo() internal view returns (ISetup.PoolSetupInfo memory) {
+        PoolStorage storage $ = _getPoolStorage();
+        return ISetup.PoolSetupInfo(
+            getProductNftId(),
+            $._tokenHandler,
+            isNftInterceptor(),
+            $._isExternallyManaged,
+            $._isVerifyingApplications,
+            $._collateralizationLevel,
+            $._retentionLevel,
+            $._initialPoolFee,
+            $._initialStakingFee,
+            $._initialPerformanceFee,
+            getWallet()
         );
-
-        emit LogUnderwrittenByPool(policyNftId, collateralizationAmount, address(this));
     }
 
+    // Internals
+
     function _createBundle(
         address bundleOwner,
         Fee memory fee,
         uint256 amount,
         uint256 lifetime, 
-        bytes calldata filter
+        bytes memory filter
     )
         internal
         returns(NftId bundleNftId)
     {
-        bundleNftId = _poolService.createBundle(
+        bundleNftId = _getPoolStorage()._bundleService.createBundle(
             bundleOwner,
             fee,
             amount,
             lifetime,
-            filter
-        );
-    }
+            filter);
 
-    // from pool component
-    function getPoolFee()
-        external
-        view
-        override
-        returns (Fee memory poolFee)
-    {
-        NftId productNftId = _instance.getProductNftId(getNftId());
-        if (_instance.hasTreasuryInfo(productNftId)) {
-            return _instance.getTreasuryInfo(productNftId).poolFee;
-        } else {
-            return _initialPoolFee;
-        }
+        // TODO add logging
     }
 
-    function getStakingFee()
-        external
-        view
-        override
-        returns (Fee memory stakingFee)
-    {
-        NftId productNftId = _instance.getProductNftId(getNftId());
-        if (_instance.hasTreasuryInfo(productNftId)) {
-            return _instance.getTreasuryInfo(productNftId).stakingFee;
-        } else {
-            return _initialStakingFee;
-        }
+    function getContractLocation(bytes memory name) external pure returns (bytes32 hash) {
+        return keccak256(abi.encode(uint256(keccak256(name)) - 1)) & ~bytes32(uint256(0xff));
     }
 
-    function getPerformanceFee()
-        external
-        view
-        override
-        returns (Fee memory performanceFee)
-    {
-        NftId productNftId = _instance.getProductNftId(getNftId());
-        if (_instance.hasTreasuryInfo(productNftId)) {
-            return _instance.getTreasuryInfo(productNftId).performanceFee;
-        } else {
-            return _initialPerformanceFee;
+    function _getPoolStorage() private pure returns (PoolStorage storage $) {
+        assembly {
+            $.slot := POOL_STORAGE_LOCATION_V1
         }
     }
-
-    // from registerable
-    function getType() public pure override returns (ObjectType) {
-        return POOL();
-    }
 }