@etherisc/gif-next 0.0.2-bcecc4c-647 → 0.0.2-bd1522a-487

package/contracts/pool/Pool.sol

@@ -2,7 +2,8 @@
 pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "../type/Amount.sol";
-import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.sol";
+import {BUNDLE, COMPONENT, POLICY, POOL} from "../type/ObjectType.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
@@ -10,13 +11,13 @@ import {IPoolService} from "./IPoolService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {Fee} from "../type/Fee.sol";
+import {NftId} from "../type/NftId.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {Timestamp} from "../type/Timestamp.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
-import {UFixed, UFixedLib} from "../type/UFixed.sol";
+import {UFixed} from "../type/UFixed.sol";
 
 abstract contract Pool is
     InstanceLinkedComponent, 
@@ -26,6 +27,7 @@ abstract contract Pool is
     bytes32 public constant POOL_STORAGE_LOCATION_V1 = 0x25e3e51823fbfffb988e0a2744bb93722d9f3e906c07cc0a9e77884c46c58300;
 
     struct PoolStorage {
+        IComponents.PoolInfo _poolInfo;
         IComponentService _componentService;
         IPoolService _poolService;
         IBundleService _bundleService;
@@ -40,23 +42,29 @@ abstract contract Pool is
     }
 
 
+    // 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));
+    }
+
+
     /// @dev see {IPoolComponent.verifyApplication}
     function verifyApplication(
         NftId applicationNftId, 
-        bytes memory applicationData,
         NftId bundleNftId, 
-        bytes memory bundleFilter,
         Amount collateralizationAmount
     )
         public
         virtual
         restricted()
+        onlyNftOfType(applicationNftId, POLICY())
     {
+        InstanceReader reader = _getInstanceReader();
         if(!applicationMatchesBundle(
             applicationNftId,
-            applicationData, 
+            reader.getPolicyInfo(applicationNftId).applicationData, 
             bundleNftId, 
-            bundleFilter,
+            reader.getBundleInfo(bundleNftId).filter,
             collateralizationAmount)
         )
         {
@@ -67,9 +75,25 @@ abstract contract Pool is
     }
 
 
+    /// @dev see {IPoolComponent.processConfirmedClaim}
+    function processConfirmedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount amount
+    )
+        public
+        virtual
+        restricted()
+        onlyNftOfType(policyNftId, POLICY())
+    {
+        // default implementation is empty
+    }
+
+
     /// @dev see {IPoolComponent.applicationMatchesBundle}
-    /// Override this function to implement any custom application verification 
-    /// Default implementation always returns true
+    /// Default implementation always returns true.
+    /// Override this function to implement any custom application verification.
+    /// Calling super.applicationMatchesBundle will ensure validation of application and bundle nft ids.
     function applicationMatchesBundle(
         NftId applicationNftId, 
         bytes memory applicationData,
@@ -80,65 +104,32 @@ abstract contract Pool is
         public
         virtual
         view
+        onlyNftOfType(applicationNftId, POLICY())
+        onlyNftOfType(bundleNftId, BUNDLE())
         returns (bool isMatching)
     {
         return true;
     }
 
 
-    function register()
-        external
-        virtual
-        onlyOwner()
-    {
-        _getPoolStorage()._componentService.registerPool();
-        _approveTokenHandler(type(uint256).max);
-    }
-
-    /// @inheritdoc IPoolComponent
-    function withdrawBundleFees(NftId bundleNftId, Amount amount) 
-        external 
-        virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
-        returns (Amount withdrawnAmount) 
-    {
-        return _withdrawBundleFees(bundleNftId, amount);
-    }
-
-
     function getInitialPoolInfo()
         public 
         virtual 
         view 
         returns (IComponents.PoolInfo memory poolInfo)
     {
-        return IComponents.PoolInfo(
-            NftIdLib.zero(), // will be set when GIF registers the related product
-            PUBLIC_ROLE(), // bundleOwnerRole
-            AmountLib.max(), // maxCapitalAmount,
-            isNftInterceptor(), // isInterceptingBundleTransfers
-            false, // isExternallyManaged,
-            false, // isVerifyingApplications,
-            UFixedLib.toUFixed(1), // collateralizationLevel,
-            UFixedLib.toUFixed(1), // retentionLevel,
-            FeeLib.zero(), // initialPoolFee,
-            FeeLib.zero(), // initialStakingFee,
-            FeeLib.zero() // initialPerformanceFee,
-        );
+        return _getPoolStorage()._poolInfo;
     }
 
     // Internals
 
     function _initializePool(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         string memory name,
-        address token,
+        IComponents.PoolInfo memory poolInfo,
         IAuthorization authorization,
-        bool isInterceptingNftTransfers,
         address initialOwner,
-        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
         bytes memory componentData // component specifidc data 
     )
         internal
@@ -147,24 +138,106 @@ abstract contract Pool is
     {
         _initializeInstanceLinkedComponent(
             registry, 
-            instanceNftId, 
+            productNftId,  
             name, 
-            token, 
             POOL(), 
             authorization, 
-            isInterceptingNftTransfers, 
+            poolInfo.isInterceptingBundleTransfers, 
             initialOwner, 
-            registryData, 
             componentData);
 
         PoolStorage storage $ = _getPoolStorage();
+
+        $._poolInfo = poolInfo;
         $._poolService = IPoolService(_getServiceAddress(POOL())); 
         $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
 
-        registerInterface(type(IPoolComponent).interfaceId);
+        _registerInterface(type(IPoolComponent).interfaceId);
+    }
+
+
+    /// @dev Update pool fees to the specified values.
+    /// Pool fee: are deducted from the premium amount and goes to the pool owner.
+    /// Staking fee: are deducted from the staked tokens by a bundle owner and goes to the pool owner.
+    /// Performance fee: 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 _setPoolFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        internal
+        virtual
+    {
+        _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
+    }
+
+
+    /// @dev Sets the maximum balance amound held by this pool.
+    /// Function may only be called by pool owner.
+    function _setMaxBalanceAmount(Amount maxBalanceAmount)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
+    }
+
+
+    /// @dev Fund the pool wallet with the specified amount.
+    /// Function is only available for externally managed pools.
+    function _fundPoolWallet(Amount amount)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.fundPoolWallet(amount);
+    }
+
+
+    /// @dev Withdraw the specified amount from the pool wallet.
+    /// Function is only available for externally managed pools.
+    function _defundPoolWallet(Amount amount)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.defundPoolWallet(amount);
+    }
+
+
+    /// @dev Creates a new empty bundle using the provided parameter values.
+    function _createBundle(
+        address bundleOwner,
+        Fee memory fee,
+        Seconds lifetime, 
+        bytes memory filter
+    )
+        internal
+        returns(NftId bundleNftId)
+    {
+        bundleNftId = _getPoolStorage()._bundleService.create(
+            bundleOwner,
+            fee,
+            lifetime,
+            filter);
+
+        // TODO add logging
+    }
+
+
+    /// @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
+    )
+        internal
+        virtual
+    {
+        _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
     }
 
+
     /// @dev increases the staked tokens by the specified amount
     /// bundle MUST be in active or locked state
     function _stake(
@@ -173,9 +246,9 @@ abstract contract Pool is
     )
         internal
         virtual
-        returns(Amount netAmount) 
+        returns(Amount) 
     {
-        _getPoolStorage()._poolService.stake(bundleNftId, amount);
+        return _getPoolStorage()._poolService.stake(bundleNftId, amount);
     }
 
 
@@ -233,7 +306,7 @@ abstract contract Pool is
     /// 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)
+    function _closeBundle(NftId bundleNftId)
         internal
         virtual
     {
@@ -241,88 +314,26 @@ abstract contract Pool is
     }
 
 
-    /// @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
-    )
-        internal
-        virtual
-    {
-        _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
-    }
-
-
-    /// @dev Sets the maximum overall capital amound held by this pool.
-    /// Function may only be called by pool owner.
-    function _setMaxCapitalAmount(Amount maxCapitalAmount)
-        internal
-        virtual
-    {
-        _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
-    }
-
-    /// @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)
+    /// @dev Withdraws the specified amount of fees from the bundle.
+    function _withdrawBundleFees(NftId bundleNftId, Amount amount) 
         internal
-        virtual
+        returns (Amount withdrawnAmount) 
     {
-        _getPoolStorage()._poolService.setBundleOwnerRole(bundleOwnerRole);
+        return _getPoolStorage()._poolService.withdrawBundleFees(bundleNftId, amount);
     }
 
 
-    /// @dev Update pool fees to the specified values.
-    /// Pool fee: are deducted from the premium amount and goes to the pool owner.
-    /// Staking fee: are deducted from the staked tokens by a bundle owner and goes to the pool owner.
-    /// Performance fee: 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 _setPoolFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    )
-        internal
-        virtual
-    {
-        _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
-    }
-
-    /// @dev Creates a new bundle using the provided parameter values.
-    function _createBundle(
-        address bundleOwner,
-        Fee memory fee,
-        Amount amount,
-        Seconds lifetime, 
-        bytes memory filter
+    function _processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
     )
         internal
-        returns(NftId bundleNftId)
     {
-        bundleNftId = _getPoolStorage()._poolService.createBundle(
-            bundleOwner,
-            fee,
-            amount,
-            lifetime,
-            filter);
-
-        // TODO add logging
+        _getPoolStorage()._poolService.processFundedClaim(
+            policyNftId, claimId, availableAmount);
     }
 
-    // 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 _withdrawBundleFees(NftId bundleNftId, Amount amount) 
-        internal
-        returns (Amount withdrawnAmount) 
-    {
-        return _getPoolStorage()._bundleService.withdrawBundleFees(bundleNftId, amount);
-    }
 
     function _getPoolStorage() private pure returns (PoolStorage storage $) {
         assembly {

package/contracts/pool/PoolLib.sol

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {INftOwnable} from "../shared/INftOwnable.sol";
+import {IPolicyHolder} from "../shared/IPolicyHolder.sol";
+import {IPoolService} from "./IPoolService.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, BUNDLE, POOL} from "../type/ObjectType.sol";
+import {UFixed} from "../type/UFixed.sol";
+
+library PoolLib {
+
+    /// @dev Calulate required collateral for the provided parameters.
+    function calculateRequiredCollateral(
+        InstanceReader instanceReader,
+        NftId productNftId, 
+        Amount sumInsuredAmount
+    )
+        public
+        view 
+        returns(
+            NftId poolNftId,
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount,
+            bool poolIsVerifyingApplications
+        )
+    {
+        poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+        poolIsVerifyingApplications = poolInfo.isVerifyingApplications;
+
+        (
+            totalCollateralAmount,
+            localCollateralAmount
+        ) = calculateRequiredCollateral(
+            poolInfo.collateralizationLevel,
+            poolInfo.retentionLevel,
+            sumInsuredAmount);
+    }
+
+
+    /// @dev calulate required collateral for the provided parameters.
+    /// Collateralization is applied to sum insured.
+    /// Retention level defines the fraction of the collateral that is required locally.
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        UFixed retentionLevel, 
+        Amount sumInsuredAmount
+    )
+        public
+        pure 
+        returns(
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
+        )
+    {
+        // collateralization is applied to sum insured
+        UFixed totalUFixed = collateralizationLevel * sumInsuredAmount.toUFixed();
+        totalCollateralAmount = AmountLib.toAmount(totalUFixed.toInt());
+
+        // retention level defines how much capital is required locally
+        localCollateralAmount = AmountLib.toAmount(
+            (retentionLevel * totalUFixed).toInt());
+    }
+
+
+    function calculateStakingAmounts(
+        IRegistry registry,
+        InstanceReader instanceReader,
+        NftId poolNftId,
+        Amount stakingAmount
+    )
+        public
+        view
+        returns (
+            Amount feeAmount,
+            Amount netStakingAmount
+        )
+    {
+        NftId productNftId = registry.getParentNftId(poolNftId);
+        Fee memory stakingFee = instanceReader.getFeeInfo(productNftId).stakingFee;
+        (
+            feeAmount,
+            netStakingAmount
+        ) = FeeLib.calculateFee(
+            stakingFee, 
+            stakingAmount);
+    }
+
+
+    function calculatePayoutAmounts(
+        IRegistry registry,
+        InstanceReader instanceReader,
+        NftId productNftId,
+        NftId policyNftId,
+        Amount payoutAmount,
+        address payoutBeneficiary
+    )
+        external
+        view
+        returns (
+            Amount netPayoutAmount,
+            Amount processingFeeAmount,
+            address beneficiary
+        )
+    {
+        // Amount payoutAmount = payoutInfo.amount;
+
+        if(payoutAmount.gtz()) {
+            netPayoutAmount = payoutAmount;
+
+            if (payoutBeneficiary == address(0)) {
+                beneficiary = registry.ownerOf(policyNftId);
+            } else { 
+                beneficiary = payoutBeneficiary;
+            }
+
+            // calculate processing fees if applicable
+            IComponents.FeeInfo memory feeInfo = instanceReader.getFeeInfo(productNftId);
+            if(FeeLib.gtz(feeInfo.processingFee)) {
+                // TODO calculate and set net payout and processing fees
+            }
+        }
+    }
+
+
+    function getPolicyHolder(
+        IRegistry registry, 
+        NftId policyNftId
+    )
+        internal 
+        view 
+        returns (IPolicyHolder policyHolder)
+    {
+        address policyHolderAddress = registry.ownerOf(policyNftId);
+        policyHolder = IPolicyHolder(policyHolderAddress);
+
+        if (!ContractLib.isPolicyHolder(policyHolderAddress)) {
+            policyHolder = IPolicyHolder(address(0));
+        }
+    }
+
+
+    function checkAndGetPoolInfo(
+        IRegistry registry,
+        address sender,
+        NftId bundleNftId
+    )
+        public
+        view
+        returns (
+            InstanceReader instanceReader,
+            InstanceStore instanceStore,
+            NftId instanceNftId,
+            NftId poolNftId,
+            IComponents.PoolInfo memory poolInfo
+        )
+    {
+        checkNftType(registry, bundleNftId, BUNDLE());
+
+        IInstance instance;
+        (poolNftId, instance) = getAndVerifyActivePool(registry, sender);
+        instanceReader = instance.getInstanceReader();
+        instanceStore = instance.getInstanceStore();
+        instanceNftId = instance.getNftId();
+        poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+        if (registry.getParentNftId(bundleNftId) != poolNftId) {
+            revert IPoolService.ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+    }
+
+
+    function getAndVerifyActivePool(
+        IRegistry registry,
+        address sender
+    )
+        public
+        view
+        returns (
+            NftId poolNftId,
+            IInstance instance
+        )
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyComponent(
+            registry, 
+            sender,
+            POOL(),
+            true); // only active pools
+
+        poolNftId = info.nftId;
+        instance = IInstance(instanceAddress);
+    }
+
+    function checkNftType(
+        IRegistry registry, 
+        NftId nftId, 
+        ObjectType expectedObjectType
+    ) internal view {
+        if(!registry.isObjectType(nftId, expectedObjectType)) {
+            revert INftOwnable.ErrorNftOwnableInvalidType(nftId, expectedObjectType);
+        }
+    }
+}