@etherisc/gif-next 0.0.2-f13c010-035 → 0.0.2-f13d67f-541

package/contracts/pool/IPoolService.sol

@@ -1,39 +1,46 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount} from "../type/Amount.sol";
-import {ClaimId} from "../type/ClaimId.sol";
-import {Fee} from "../type/Fee.sol";
-import {IBundle} from "../instance/module/IBundle.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
 import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
 import {NftId} from "../type/NftId.sol";
 import {PayoutId} from "../type/PayoutId.sol";
-import {RoleId} from "../type/RoleId.sol";
-import {Seconds} from "../type/Seconds.sol";
-import {StateId} from "../type/StateId.sol";
-import {UFixed} from "../type/UFixed.sol";
 
 interface IPoolService is IService {
 
     event LogPoolServiceMaxBalanceAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
-    event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
+    event LogPoolServiceWalletFunded(NftId poolNftId, address poolOwner, Amount amount);
+    event LogPoolServiceWalletDefunded(NftId poolNftId, address poolOwner, Amount amount);
 
     event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
     event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
 
     event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
-    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount);
+    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+
+    event LogPoolServiceFeesWithdrawn(NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
 
     event LogPoolServiceProcessFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount);
 
+    event LogPoolServiceApplicationVerified(NftId poolNftId, NftId bundleNftId, NftId applicationNftId, Amount totalCollateralAmount);
+    event LogPoolServiceCollateralLocked(NftId poolNftId, NftId bundleNftId, NftId applicationNftId, Amount totalCollateralAmount, Amount lockedCollateralAmount);
+    event LogPoolServiceCollateralReleased(NftId bundleNftId, NftId policyNftId, Amount remainingCollateralAmount);
+    event LogPoolServiceSaleProcessed(NftId poolNftId, NftId bundleNftId, Amount bundleNetAmount, Amount bundleFeeAmount, Amount poolFeeAmount);
+    event LogPoolServicePayoutProcessed(NftId poolNftId, NftId bundleNftId, NftId policyNftId, PayoutId payoutId, Amount netPayoutAmount, Amount processingFeeAmount, address payoutBeneficiary);
+
+    error ErrorPoolServicePoolNotExternallyManaged(NftId poolNftId);
     error ErrorPoolServicePolicyPoolMismatch(NftId policyNftId, NftId productNftId, NftId expectedProductNftId);
     error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
     error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
     error ErrorPoolServiceBundlePoolMismatch(NftId bundleNftId, NftId poolNftId);
     error ErrorPoolServiceMaxBalanceAmountExceeded(NftId poolNftId, Amount maxBalanceAmount, Amount currentBalanceAmount, Amount transferAmount);
+    error ErrorPoolServiceFeesWithdrawAmountExceedsLimit(Amount amount, Amount limit);
 
     /// @dev sets the max balance amount for the calling pool
     function setMaxBalanceAmount(Amount maxBalanceAmount) external;
@@ -62,7 +69,6 @@ interface IPoolService is IService {
     /// may only be called by the policy service for unlocked pool components
     function releaseCollateral(
         IInstance instance, 
-        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo
     ) external;
@@ -72,24 +78,15 @@ interface IPoolService is IService {
     /// 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 processPayout(
-        IInstance instance, 
-        address token,
+        InstanceReader instanceReader,
+        InstanceStore instanceStore, 
+        NftId productNftId,
         NftId policyNftId, 
-        IPolicy.PolicyInfo memory policyInfo,
-        Amount payoutAmount
-    ) external;
-
-
-    /// @dev create a new empty bundle with the provided parameters
-    /// may only be called by registered and unlocked pool components.
-    function createBundle(
-        address owner, // initial bundle owner
-        Fee memory fee, // fees deducted from premium that go to bundle owner
-        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
+        NftId bundleNftId,
+        PayoutId payoutId,
+        Amount payoutAmount,
+        address payoutBeneficiary
+    ) external returns (Amount netPayoutAmount, Amount processingFeeAmount);
 
 
     /// @dev increase stakes for bundle
@@ -112,56 +109,62 @@ interface IPoolService is IService {
     function closeBundle(NftId bundleNftId) external;
 
 
+    /// @dev Withdraw bundle feeds for the specified bundle.
+    function withdrawBundleFees(NftId bundleNftId, Amount amount) external returns (Amount withdrawnAmount);
+
+
     /// @dev Informs product about available funds to process a confirmed claim.
     /// The function triggers a callback to the product component when the product's property isProcessingFundedClaims is set.
     function processFundedClaim(NftId policyNftId, ClaimId claimId, Amount availableAmount) external;
 
 
-    /// @dev Fund the specified pool wallet with the provided amount.
-    /// This function will collect the amount from the sender address and transfers it to the pool wallet.
+    /// @dev Fund the pool wallet with the provided amount.
+    /// This function will collect the amount from the pool owner and transfers it to the pool wallet.
     /// The function will not update balance amounts managed by the framework.
     /// Only available for externally managed pools.
-    function fundPoolWallet(NftId poolNftId, Amount amount) external;
+    function fundPoolWallet(Amount amount) external;
 
 
     /// @dev Defund the specified pool wallet with the provided amount.
-    /// This function will transfer the amount from the pool wallet to the sender address.
+    /// This function will transfer the amount from the pool wallet to the pool owner.
     /// The function will not update balance amounts managed by the framework.
     /// Only available for externally managed pools.
-    function defundPoolWallet(NftId poolNftId, Amount amount) external;
+    function defundPoolWallet(Amount amount) external;
 
 
     /// @dev processes the sale of a bundle and track the pool fee and bundle fee amounts
     function processSale(NftId bundleNftId, IPolicy.PremiumInfo memory premium) external;
 
 
-    /// @dev Calulate required collateral for the provided parameters.
-    function calculateRequiredCollateral(
-        InstanceReader instanceReader,
-        NftId productNftId, 
-        Amount sumInsuredAmount
-    )
-        external
-        view 
-        returns(
-            Amount totalCollateralAmount,
-            Amount localCollateralAmount
-        );
-
-
-    /// @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
-    )
-        external
-        pure 
-        returns(
-            Amount totalCollateralAmount,
-            Amount localCollateralAmount
-        );
+    // /// @dev Calulate required collateral for the provided parameters.
+    // function calculateRequiredCollateral(
+    //     InstanceReader instanceReader,
+    //     NftId productNftId, 
+    //     Amount sumInsuredAmount
+    // )
+    //     external
+    //     view 
+    //     returns(
+    //         NftId poolNftId,
+    //         Amount totalCollateralAmount,
+    //         Amount localCollateralAmount,
+    //         bool poolIsVerifyingApplications
+    //     );
+
+
+    // /// @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
+    // )
+    //     external
+    //     pure 
+    //     returns(
+    //         Amount totalCollateralAmount,
+    //         Amount localCollateralAmount
+    //     );
 
 }

package/contracts/pool/Pool.sol

@@ -11,12 +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 {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 {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,12 +42,16 @@ 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
@@ -53,11 +59,12 @@ abstract contract Pool is
         restricted()
         onlyNftOfType(applicationNftId, POLICY())
     {
+        InstanceReader reader = _getInstanceReader();
         if(!applicationMatchesBundle(
             applicationNftId,
-            applicationData, 
+            reader.getPolicyInfo(applicationNftId).applicationData, 
             bundleNftId, 
-            bundleFilter,
+            reader.getBundleInfo(bundleNftId).filter,
             collateralizationAmount)
         )
         {
@@ -84,8 +91,9 @@ abstract contract Pool is
 
 
     /// @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,
@@ -103,18 +111,6 @@ abstract contract Pool is
         return true;
     }
 
-    /// @inheritdoc IPoolComponent
-    function withdrawBundleFees(NftId bundleNftId, Amount amount) 
-        external 
-        virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
-        onlyNftOfType(bundleNftId, BUNDLE())
-        returns (Amount withdrawnAmount) 
-    {
-        return _withdrawBundleFees(bundleNftId, amount);
-    }
-
 
     function getInitialPoolInfo()
         public 
@@ -122,46 +118,35 @@ abstract contract Pool is
         view 
         returns (IComponents.PoolInfo memory poolInfo)
     {
-        return IComponents.PoolInfo({
-            maxBalanceAmount: AmountLib.max(),
-            bundleOwnerRole: PUBLIC_ROLE(), 
-            isInterceptingBundleTransfers: isNftInterceptor(),
-            isProcessingConfirmedClaims: false,
-            isExternallyManaged: false,
-            isVerifyingApplications: false,
-            collateralizationLevel: UFixedLib.toUFixed(1),
-            retentionLevel: UFixedLib.toUFixed(1)
-        });
+        return _getPoolStorage()._poolInfo;
     }
 
     // Internals
 
-    function _initializePool(
+    function __Pool_init(
         address registry,
         NftId productNftId,
         string memory name,
-        address token,
+        IComponents.PoolInfo memory poolInfo,
         IAuthorization authorization,
-        bool isInterceptingNftTransfers,
-        address initialOwner,
-        bytes memory componentData // component specifidc data 
+        address initialOwner
     )
         internal
         virtual
         onlyInitializing()
     {
-        _initializeInstanceLinkedComponent(
+        __InstanceLinkedComponent_init(
             registry, 
             productNftId,  
             name, 
-            token, 
             POOL(), 
             authorization, 
-            isInterceptingNftTransfers, 
-            initialOwner, 
-            componentData);
+            poolInfo.isInterceptingBundleTransfers, 
+            initialOwner);
 
         PoolStorage storage $ = _getPoolStorage();
+
+        $._poolInfo = poolInfo;
         $._poolService = IPoolService(_getServiceAddress(POOL())); 
         $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
@@ -169,79 +154,71 @@ abstract contract Pool is
         _registerInterface(type(IPoolComponent).interfaceId);
     }
 
-    /// @dev increases the staked tokens by the specified amount
-    /// bundle MUST be in active or locked state
-    function _stake(
-        NftId bundleNftId, 
-        Amount amount
-    )
-        internal
-        virtual
-        returns(Amount) 
-    {
-        return _getPoolStorage()._poolService.stake(bundleNftId, amount);
-    }
-
 
-    /// @dev decreases the staked tokens by the specified amount
-    /// bundle MUST be in active, locked or closed state
-    function _unstake(
-        NftId bundleNftId, 
-        Amount 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
-        returns(Amount netAmount) 
     {
-        return _getPoolStorage()._poolService.unstake(bundleNftId, amount);
+        _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
     }
 
 
-    /// @dev extends the bundle lifetime of the bundle by the specified time
-    /// bundle MUST be in active or locked state
-    function _extend(
-        NftId bundleNftId, 
-        Seconds lifetimeExtension
-    )
+    /// @dev Sets the maximum balance amound held by this pool.
+    /// Function may only be called by pool owner.
+    function _setMaxBalanceAmount(Amount maxBalanceAmount)
         internal
         virtual
-        returns (Timestamp extendedExpiredAt) 
     {
-        return _getPoolStorage()._bundleService.extend(bundleNftId, lifetimeExtension);
+        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
     }
 
 
-    /// @dev Locks the specified bundle.
-    /// A bundle to be locked MUST be in active state.
-    /// Locked bundles may not be used to collateralize any new policy.
-    function _lockBundle(NftId bundleNftId)
+    /// @dev Fund the pool wallet with the specified amount.
+    /// Function is only available for externally managed pools.
+    function _fundPoolWallet(Amount amount)
         internal
         virtual
     {
-        _getPoolStorage()._bundleService.lock(bundleNftId);
+        _getPoolStorage()._poolService.fundPoolWallet(amount);
     }
 
 
-    /// @dev Unlocks the specified bundle.
-    /// A bundle to be unlocked MUST be in locked state.
-    function _unlockBundle(NftId bundleNftId)
+    /// @dev Withdraw the specified amount from the pool wallet.
+    /// Function is only available for externally managed pools.
+    function _defundPoolWallet(Amount amount)
         internal
         virtual
     {
-        _getPoolStorage()._bundleService.unlock(bundleNftId);
+        _getPoolStorage()._poolService.defundPoolWallet(amount);
     }
 
 
-    /// @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 _closeBundle(NftId bundleNftId)
+    /// @dev Creates a new empty bundle using the provided parameter values.
+    function _createBundle(
+        address bundleOwner,
+        Fee memory fee,
+        Seconds lifetime, 
+        bytes memory filter
+    )
         internal
-        virtual
+        returns(NftId bundleNftId)
     {
-        _getPoolStorage()._poolService.closeBundle(bundleNftId);
+        bundleNftId = _getPoolStorage()._bundleService.create(
+            bundleOwner,
+            fee,
+            lifetime,
+            filter);
+
+        // TODO add logging
     }
 
 
@@ -259,63 +236,81 @@ abstract contract Pool is
     }
 
 
-    /// @dev Sets the maximum balance amound held by this pool.
-    /// Function may only be called by pool owner.
-    function _setMaxBalanceAmount(Amount maxBalanceAmount)
+    /// @dev increases the staked tokens by the specified amount
+    /// bundle MUST be in active or locked state
+    function _stake(
+        NftId bundleNftId, 
+        Amount amount
+    )
         internal
         virtual
+        returns(Amount) 
     {
-        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
+        return _getPoolStorage()._poolService.stake(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
+    /// @dev decreases the staked tokens by the specified amount
+    /// bundle MUST be in active, locked or closed state
+    function _unstake(
+        NftId bundleNftId, 
+        Amount amount
     )
         internal
         virtual
+        returns(Amount netAmount) 
     {
-        _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
+        return _getPoolStorage()._poolService.unstake(bundleNftId, amount);
     }
 
-    /// @dev Creates a new empty bundle using the provided parameter values.
-    function _createBundle(
-        address bundleOwner,
-        Fee memory fee,
-        Seconds lifetime, 
-        bytes memory filter
+
+    /// @dev extends the bundle lifetime of the bundle by the specified time
+    /// bundle MUST be in active or locked state
+    function _extend(
+        NftId bundleNftId, 
+        Seconds lifetimeExtension
     )
         internal
-        returns(NftId bundleNftId)
+        virtual
+        returns (Timestamp extendedExpiredAt) 
     {
-        bundleNftId = _getPoolStorage()._poolService.createBundle(
-            bundleOwner,
-            fee,
-            lifetime,
-            filter);
+        return _getPoolStorage()._bundleService.extend(bundleNftId, lifetimeExtension);
+    }
 
-        // TODO add logging
+
+    /// @dev Locks the specified bundle.
+    /// A bundle to be locked MUST be in active state.
+    /// Locked bundles may not be used to collateralize any new policy.
+    function _setBundleLocked(NftId bundleNftId, bool locked)
+        internal
+        virtual
+    {
+        _getPoolStorage()._bundleService.setLocked(bundleNftId, locked);
     }
 
-    // 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 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 _closeBundle(NftId bundleNftId)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.closeBundle(bundleNftId);
     }
 
+
+    /// @dev Withdraws the specified amount of fees from the bundle.
     function _withdrawBundleFees(NftId bundleNftId, Amount amount) 
         internal
         returns (Amount withdrawnAmount) 
     {
-        return _getPoolStorage()._bundleService.withdrawBundleFees(bundleNftId, amount);
+        return _getPoolStorage()._poolService.withdrawBundleFees(bundleNftId, amount);
     }
 
+
     function _processFundedClaim(
         NftId policyNftId, 
         ClaimId claimId, 
@@ -327,6 +322,7 @@ abstract contract Pool is
             policyNftId, claimId, availableAmount);
     }
 
+
     function _getPoolStorage() private pure returns (PoolStorage storage $) {
         assembly {
             $.slot := POOL_STORAGE_LOCATION_V1