@etherisc/gif-next 0.0.2-ebbe63d → 0.0.2-ebf1a6b-485

package/contracts/components/IDistributionComponent.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Fee} from "../types/Fee.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 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 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;
+
+    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 component needs to be called when selling/renewing policis
+    function isVerifying() external view returns (bool verifying);
+}

package/contracts/components/IPoolComponent.sol

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+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 {RoleId} from "../types/RoleId.sol";
+import {Seconds} from "../types/Seconds.sol";
+import {UFixed} from "../types/UFixed.sol";
+
+/// @dev pool components hold and manage the collateral to cover active policies
+/// pools come in different flavors
+interface IPoolComponent is IComponent {
+
+    error ErrorPoolNotBundleOwner(NftId bundleNftId, address caller);
+    error ErrorPoolNotPoolService(address caller);
+
+    error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
+    error ErrorPoolBundleOwnerRoleAlreadySet();
+
+    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, uint256 collateralizationAmount);
+    event LogPoolBundleMaxCapitalAmountUpdated(uint256 previousMaxCapitalAmount, uint256 currentMaxCapitalAmount);
+    event LogPoolBundleOwnerRoleSet(RoleId bundleOwnerRole);
+
+    /// @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 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 bundleNftId, 
+        Fee memory fee
+    ) external;
+
+    /// @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 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);
+
+    /// @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 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);
+
+    /// @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 the maximum overall capital amound held by this pool
+    function getMaxCapitalAmount() external view returns (uint256 maxCapitalAmount);
+
+    /// @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);
+
+    /// @dev returns the required role for bundle owners
+    /// default emplementation returns PUBLIC_ROLE
+    /// the PUBLIC_ROLE role implies that no specific roole is required for bundle owners
+    function getBundleOwnerRole() external view returns (RoleId bundleOwnerRole);
+
+    /// @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);
+
+    /// @dev returns setup infos for this pool
+    /// when registered with an instance the setup info is obtained from the data stored in the instance
+    /// when not registered the function returns the initial setup info
+    function getSetupInfo() external view returns (ISetup.PoolSetupInfo memory setupInfo);
+
+}

package/contracts/components/IProductComponent.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+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/Referral.sol";
+import {RiskId} from "../types/RiskId.sol";
+import {Seconds} from "../types/Seconds.sol";
+
+interface IProductComponent is IComponent {
+
+    function getSetupInfo() external view returns (ISetup.ProductSetupInfo memory setupInfo);
+
+    function setFees(
+        Fee memory productFee,
+        Fee memory processingFee
+    ) external;
+
+    function calculatePremium(
+        uint256 sumInsuredAmount,
+        RiskId riskId,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    ) external view returns (uint256 premiumAmount);
+
+    function calculateNetPremium(
+        uint256 sumInsuredAmount,
+        RiskId riskId,
+        Seconds lifetime,
+        bytes memory applicationData
+    ) external view returns (uint256 netPremiumAmount);    
+
+    
+    function getPoolNftId() external view returns (NftId poolNftId);
+    function getDistributionNftId() external view returns (NftId distributionNftId);
+}

package/contracts/components/Pool.sol

@@ -0,0 +1,378 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Component} from "./Component.sol";
+import {Fee, FeeLib} from "../types/Fee.sol";
+import {IBundleService} from "../instance/service/IBundleService.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IPoolComponent} from "./IPoolComponent.sol";
+import {IPoolService} from "../instance/service/IPoolService.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
+import {NftId, NftIdLib} from "../types/NftId.sol";
+import {POOL} from "../types/ObjectType.sol";
+import {RoleId, PUBLIC_ROLE} from "../types/RoleId.sol";
+import {Seconds} from "../types/Seconds.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {UFixed} from "../types/UFixed.sol";
+
+
+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;
+
+    struct PoolStorage {
+        UFixed _collateralizationLevel;
+        UFixed _retentionLevel;
+        uint256 _maxCapitalAmount;
+        
+        bool _isExternallyManaged;
+        bool _isVerifyingApplications;
+
+        RoleId _bundleOwnerRole;
+        bool _isInterceptingBundleTransfers;
+
+        Fee _initialPoolFee;
+        Fee _initialStakingFee;
+        Fee _initialPerformanceFee;
+
+        TokenHandler _tokenHandler;
+
+        // may be used to interact with instance by derived contracts
+        IPoolService _poolService;
+        IBundleService _bundleService;
+    }
+
+
+    modifier onlyBundleOwner(NftId bundleNftId) {
+        if(msg.sender != getRegistry().ownerOf(bundleNftId)) {
+            revert ErrorPoolNotBundleOwner(bundleNftId, msg.sender);
+        }
+        _;
+    }
+
+
+    modifier onlyPoolService() {
+        if(msg.sender != address(_getPoolStorage()._poolService)) {
+            revert ErrorPoolNotPoolService(msg.sender);
+        }
+        _;
+    }
+
+
+    function initializePool(
+        address registry,
+        NftId instanceNftId,
+        string memory name,
+        address token,
+        bool isInterceptingNftTransfers,
+        bool isExternallyManaging,
+        bool isVerifying,
+        UFixed collateralizationLevel,
+        UFixed retentionLevel,
+        address initialOwner,
+        bytes memory registryData // writeonly data that will saved in the object info record of the registry
+    )
+        public
+        virtual
+        onlyInitializing()
+    {
+        initializeComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, registryData);
+
+        PoolStorage storage $ = _getPoolStorage();
+        // TODO add validation
+        $._tokenHandler = new TokenHandler(token);
+        $._maxCapitalAmount = type(uint256).max;
+        $._isExternallyManaged = isExternallyManaging;
+        $._isVerifyingApplications = isVerifying;
+        $._bundleOwnerRole = PUBLIC_ROLE();
+        $._collateralizationLevel = collateralizationLevel;
+        $._retentionLevel = retentionLevel;
+        $._initialPoolFee = FeeLib.zeroFee();
+        $._initialStakingFee = FeeLib.zeroFee();
+        $._initialPerformanceFee = FeeLib.zeroFee();
+        $._poolService = getInstance().getPoolService();
+        $._bundleService = getInstance().getBundleService();
+
+        registerInterface(type(IPoolComponent).interfaceId);
+    }
+
+
+    function stake(
+        NftId bundleNftId, 
+        uint256 amount
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        // TODO add implementation
+    }
+
+
+    function unstake(
+        NftId bundleNftId, 
+        uint256 amount
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        // TODO add implementation
+    }
+
+
+    function extend(
+        NftId bundleNftId, 
+        Seconds lifetimeExtension
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        // TODO add implementation
+    }
+
+
+    function lockBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.lockBundle(bundleNftId);
+    }
+
+
+    function unlockBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.unlockBundle(bundleNftId);
+    }
+
+
+    function close(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        // TODO add implementation
+    }
+
+
+    function setBundleFee(
+        NftId bundleNftId, 
+        Fee memory fee
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.setBundleFee(bundleNftId, fee);
+    }
+
+
+    function setMaxCapitalAmount(uint256 maxCapitalAmount)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        // TODO refactor to use pool service
+        // _getPoolStorage()._poolService.setMaxCapitalAmount(...);
+
+        uint256 previousMaxCapitalAmount = _getPoolStorage()._maxCapitalAmount;
+        _getPoolStorage()._maxCapitalAmount = maxCapitalAmount;
+
+        emit LogPoolBundleMaxCapitalAmountUpdated(previousMaxCapitalAmount, maxCapitalAmount);
+    }
+
+
+    function setBundleOwnerRole(RoleId bundleOwnerRole)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        // TODO refactor to use pool service
+        // _getPoolStorage()._poolService.setBundleOwnerRole(...);
+
+        if(_getPoolStorage()._bundleOwnerRole != PUBLIC_ROLE()) {
+            revert ErrorPoolBundleOwnerRoleAlreadySet();
+        }
+
+        _getPoolStorage()._bundleOwnerRole = bundleOwnerRole;
+
+        emit LogPoolBundleOwnerRoleSet(bundleOwnerRole);
+    }
+
+
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _getPoolStorage()._poolService.setFees(poolFee, stakingFee, performanceFee);
+    }
+
+
+    /// @dev see {IPool.verifyApplication}
+    function verifyApplication(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        uint256 collateralizationAmount
+    )
+        public
+        virtual
+        restricted()
+    {
+        // validate application data against bundle filter
+        if(!applicationMatchesBundle(
+            applicationNftId,
+            applicationData, 
+            bundleNftId, 
+            bundleFilter,
+            collateralizationAmount)
+        )
+        {
+            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
+        }
+
+        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
+    }
+
+
+    function getCollateralizationLevel() public view virtual returns (UFixed collateralizationLevel) {
+        return _getPoolStorage()._collateralizationLevel;
+    }
+
+
+    function getRetentionLevel() public view virtual returns (UFixed retentionLevel) {
+        return _getPoolStorage()._retentionLevel;
+    }
+
+
+    function isExternallyManaged() public view virtual returns (bool) {
+        return _getPoolStorage()._isExternallyManaged;
+    }
+
+
+    function isVerifyingApplications() public view virtual returns (bool isConfirmingApplication) {
+        return _getPoolStorage()._isVerifyingApplications;
+    }
+
+
+    function getMaxCapitalAmount() public view virtual returns (uint256 maxCapitalAmount) {
+        return _getPoolStorage()._maxCapitalAmount;
+    }
+
+
+    function isInterceptingBundleTransfers() public view virtual returns (bool) {
+        return isNftInterceptor();
+    }
+
+
+    function getBundleOwnerRole() public view returns (RoleId bundleOwnerRole) {
+        return _getPoolStorage()._bundleOwnerRole;
+    }
+
+
+    /// @dev see {IPoolComponent.applicationMatchesBundle}
+    /// Override this function to implement any custom application verification 
+    /// Default implementation always returns true
+    function applicationMatchesBundle(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        uint256 collateralizationAmount
+    )
+        public
+        view
+        virtual override
+        returns (bool isMatching)
+    {
+        return true;
+    }
+
+
+    function getSetupInfo() public view returns (ISetup.PoolSetupInfo memory setupInfo) {
+        InstanceReader reader = getInstance().getInstanceReader();
+        setupInfo = reader.getPoolSetupInfo(getNftId());
+
+        // fallback to initial setup info (wallet is always != address(0))
+        if(setupInfo.wallet == address(0)) {
+            setupInfo = _getInitialSetupInfo();
+        }
+    }
+
+    // Internals
+
+    function _createBundle(
+        address bundleOwner,
+        Fee memory fee,
+        uint256 amount,
+        Seconds lifetime, 
+        bytes memory filter
+    )
+        internal
+        returns(NftId bundleNftId)
+    {
+        bundleNftId = _getPoolStorage()._bundleService.createBundle(
+            bundleOwner,
+            fee,
+            amount,
+            lifetime,
+            filter);
+
+        // TODO add logging
+    }
+
+    // TODO remove function once this is no longer used to produce contract locations on the fly ...
+    function getContractLocation(bytes memory name) external pure returns (bytes32 hash) {
+        return keccak256(abi.encode(uint256(keccak256(name)) - 1)) & ~bytes32(uint256(0xff));
+    }
+
+
+    function _getInitialSetupInfo() internal view returns (ISetup.PoolSetupInfo memory) {
+        PoolStorage storage $ = _getPoolStorage();
+        return ISetup.PoolSetupInfo(
+            getProductNftId(),
+            $._tokenHandler,
+            $._maxCapitalAmount,
+            isNftInterceptor(),
+            $._isExternallyManaged,
+            $._isVerifyingApplications,
+            $._collateralizationLevel,
+            $._retentionLevel,
+            $._initialPoolFee,
+            $._initialStakingFee,
+            $._initialPerformanceFee,
+            getWallet()
+        );
+    }
+
+
+    function _getPoolStorage() private pure returns (PoolStorage storage $) {
+        assembly {
+            $.slot := POOL_STORAGE_LOCATION_V1
+        }
+    }
+}