@etherisc/gif-next 0.0.2-f11de3a-698 → 0.0.2-f13c010-035

package/contracts/pool/PoolService.sol

@@ -1,29 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
 import {IBundle} from "../instance/module/IBundle.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IProductComponent} from "../product/IProductComponent.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
-import {IRegistryService} from "../registry/IRegistryService.sol";
 import {IStaking} from "../staking/IStaking.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY} from "../type/ObjectType.sol";
-import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, POOL, BUNDLE, PRODUCT, POLICY, COMPONENT} from "../type/ObjectType.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {KEEP_STATE} from "../type/StateId.sol";
 import {Seconds} from "../type/Seconds.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
 import {UFixed} from "../type/UFixed.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
@@ -37,9 +33,6 @@ contract PoolService is
 {
     IBundleService internal _bundleService;
     IComponentService internal _componentService;
-    IInstanceService private _instanceService;
-    IRegistryService private _registryService;
-
     IStaking private _staking;
 
     function _initialize(
@@ -47,27 +40,24 @@ contract PoolService is
         bytes memory data
     )
         internal
-        initializer
         virtual override
+        initializer()
     {
         (
-            address registryAddress,, 
-            //address managerAddress
+            address registryAddress,
             address authority
-        ) = abi.decode(data, (address, address, address));
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, authority, owner);
+        _initializeService(registryAddress, authority, owner);
 
-        _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
         _bundleService = IBundleService(_getServiceAddress(BUNDLE()));
-        _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
         _componentService = IComponentService(_getServiceAddress(COMPONENT()));
-
         _staking = IStaking(getRegistry().getStakingAddress());
 
-        registerInterface(type(IPoolService).interfaceId);
+        _registerInterface(type(IPoolService).interfaceId);
     }
 
+
     /// @inheritdoc IPoolService
     function setMaxBalanceAmount(Amount maxBalanceAmount)
         external
@@ -75,111 +65,108 @@ contract PoolService is
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
 
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
         Amount previousMaxBalanceAmount = poolInfo.maxBalanceAmount;
-
         poolInfo.maxBalanceAmount = maxBalanceAmount;
         instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
 
         emit LogPoolServiceMaxBalanceAmountUpdated(poolNftId, previousMaxBalanceAmount, maxBalanceAmount);
     }
 
-    function setBundleOwnerRole(RoleId bundleOwnerRole)
-        external
-        virtual
-    {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
-
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
-
-        // bundle owner role may only be set once per pool
-        if(poolInfo.bundleOwnerRole != PUBLIC_ROLE()) {
-            revert ErrorPoolServiceBundleOwnerRoleAlreadySet(poolNftId);
-        }
-
-        poolInfo.bundleOwnerRole = bundleOwnerRole;
-        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
-
-        emit LogPoolServiceBundleOwnerRoleSet(poolNftId, bundleOwnerRole);
-    }
 
     /// @inheritdoc IPoolService
     function createBundle(
         address bundleOwner, // initial bundle owner
         Fee memory fee, // fees deducted from premium that go to bundle owner
-        Amount stakingAmount, // staking amount - staking fees result in initial bundle capital
         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 
         virtual
-        returns(NftId bundleNftId, Amount netStakedAmount)
+        returns(NftId bundleNftId)
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        
-        Amount stakingFeeAmount;
-        (stakingFeeAmount, netStakedAmount) = FeeLib.calculateFee(
-            _getStakingFee(instance.getInstanceReader(), poolNftId), 
-            stakingAmount);
-
-        // TODO: (staking amount + existing pool balance) must be be > maxCapitalAmount
 
+        // create the empty bundle
         bundleNftId = _bundleService.create(
             instance,
             poolNftId,
             bundleOwner,
             fee,
-            netStakedAmount,
+            AmountLib.zero(), 
             lifetime,
             filter);
 
-        // pool book keeping
-        _componentService.increasePoolBalance(
-            instance.getInstanceStore(), 
-            poolNftId, 
-            netStakedAmount, 
-            stakingFeeAmount);
-
-        // pool bookkeeping and collect tokens from bundle owner
-        _collectStakingAmount(
-            instance.getInstanceReader(), 
-            poolNftId, 
-            bundleOwner, 
-            stakingAmount);
-
         emit LogPoolServiceBundleCreated(instance.getNftId(), poolNftId, bundleNftId);
     }
 
-    function _getStakingFee(InstanceReader instanceReader, NftId poolNftId)
-        internal
-        virtual
-        view
-        returns (Fee memory stakingFee)
-    {
-        NftId productNftId = instanceReader.getComponentInfo(poolNftId).productNftId;
-        return instanceReader.getProductInfo(productNftId).stakingFee;
-    }
 
     function closeBundle(NftId bundleNftId)
         external
         virtual
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
-        // TODO book keeping for pool collateral released outside of retention level
+        // TODO get performance fee for pool (#477)
 
         // releasing collateral in bundle
-        _bundleService.close(instance, bundleNftId);
-
-        // TODO get performance fee for pool, transfer of remaining funds + bundle fees to bundle owner
+        (Amount unstakedAmount, Amount feeAmount) = _bundleService.close(instance, bundleNftId);
 
+        _componentService.decreasePoolBalance(
+            instance.getInstanceStore(), 
+            poolNftId, 
+            unstakedAmount +  feeAmount, 
+            AmountLib.zero());
+        
         emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId);
+
+        if ((unstakedAmount + feeAmount).gtz()){
+            IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolNftId);
+            poolComponentInfo.tokenHandler.distributeTokens(
+                poolComponentInfo.wallet, 
+                getRegistry().ownerOf(bundleNftId), 
+                unstakedAmount + feeAmount);
+        }
     }
 
+
+    /// @inheritdoc IPoolService
+    function processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    ) 
+        external
+        virtual
+    {
+        _checkNftType(policyNftId, POLICY());
+
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId productNftId = _getProductNftId(poolNftId);
+
+        // check policy matches with calling pool
+        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
+        if(policyInfo.productNftId != productNftId) {
+            revert ErrorPoolServicePolicyPoolMismatch(
+                policyNftId, 
+                policyInfo.productNftId, 
+                productNftId);
+        }
+
+        emit LogPoolServiceProcessFundedClaim(policyNftId, claimId, availableAmount);
+
+        // callback to product component if applicable
+        if (instanceReader.getProductInfo(productNftId).isProcessingFundedClaims) {
+            address productAddress = getRegistry().getObjectAddress(productNftId);
+            IProductComponent(productAddress).processFundedClaim(policyNftId, claimId, availableAmount);
+        }
+    }
+
+
     /// @inheritdoc IPoolService
     function stake(NftId bundleNftId, Amount amount) 
         external 
@@ -187,6 +174,8 @@ contract PoolService is
         // TODO: restricted() (once #462 is done)
         returns(Amount netAmount) 
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
@@ -196,18 +185,27 @@ contract PoolService is
             revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
         }
 
-        Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
-        if (amount + currentPoolBalance > poolInfo.maxBalanceAmount) {
-            revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, amount);
+        {
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + amount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, amount);
+            }
         }
 
         // calculate fees
-        (
-            Amount feeAmount,
-            Amount netAmount
-        ) = FeeLib.calculateFee(
-            _getStakingFee(instanceReader, poolNftId), 
-            amount);
+        IRegistry registry = getRegistry();
+        Amount feeAmount;
+
+        {
+            NftId productNftId = registry.getObjectInfo(poolNftId).parentNftId;
+            Fee memory stakingFee = instanceReader.getProductInfo(productNftId).stakingFee;
+            (
+                feeAmount,
+                netAmount
+            ) = FeeLib.calculateFee(
+                stakingFee, 
+                amount);
+        }
 
         // do all the bookkeeping
         _componentService.increasePoolBalance(
@@ -219,14 +217,15 @@ contract PoolService is
         _bundleService.stake(instance, bundleNftId, netAmount);
 
         // collect tokens from bundle owner
-        address bundleOwner = getRegistry().ownerOf(bundleNftId);
+        address bundleOwner = registry.ownerOf(bundleNftId);
+        emit LogPoolServiceBundleStaked(instance.getNftId(), poolNftId, bundleNftId, amount, netAmount);
+
+        // TODO only collect staking token when pool is not externally managed 
         _collectStakingAmount(
             instanceReader, 
             poolNftId, 
             bundleOwner, 
             amount);
-
-        emit LogPoolServiceBundleStaked(instance.getNftId(), poolNftId, bundleNftId, amount, netAmount);
     }
 
     /// @inheritdoc IPoolService
@@ -236,6 +235,8 @@ contract PoolService is
         // TODO: restricted() (once #462 is done)
         returns(Amount netAmount) 
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
         InstanceStore instanceStore = instance.getInstanceStore();
@@ -245,10 +246,6 @@ contract PoolService is
             revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
         }
 
-        if (amount.eqz()) {
-            revert ErrorPoolServiceAmountIsZero();
-        }
-
         // call bundle service for bookkeeping and additional checks
         Amount unstakedAmount = _bundleService.unstake(instance, bundleNftId, amount);
 
@@ -265,55 +262,70 @@ contract PoolService is
             AmountLib.zero());
 
         IComponents.ComponentInfo memory poolComponentInfo = instanceReader.getComponentInfo(poolNftId);
-        address poolWallet = poolComponentInfo.wallet;
-
-        // check allowance
-        {
-            IERC20Metadata token = IERC20Metadata(poolComponentInfo.token);
-            uint256 tokenAllowance = token.allowance(poolWallet, address(poolComponentInfo.tokenHandler));
-            if (tokenAllowance < unstakedAmount.toInt()) {
-                revert ErrorPoolServiceWalletAllowanceTooSmall(poolWallet, address(poolComponentInfo.tokenHandler), tokenAllowance, amount.toInt());
-            }
-        }
 
         // transfer amount to bundle owner
         address owner = getRegistry().ownerOf(bundleNftId);
-        // TODO: centralize token handling (issue #471)
-        poolComponentInfo.tokenHandler.transfer(poolWallet, owner, unstakedAmount);
-        
         emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount);
+        poolComponentInfo.tokenHandler.distributeTokens(
+            poolComponentInfo.wallet, 
+            owner, 
+            unstakedAmount);
 
         return unstakedAmount;
     }
 
+
+    function fundPoolWallet(NftId poolNftId, Amount amount)
+        external
+        virtual
+        restricted()
+    {
+        _checkNftType(poolNftId, POOL());
+        // TODO check that poolNftId is externally managed
+        // TODO implement
+    }
+
+
+    function defundPoolWallet(NftId poolNftId, Amount amount)
+        external
+        virtual
+        restricted()
+    {
+        _checkNftType(poolNftId, POOL());
+
+        // TODO check that poolNftId is externally managed
+        // TODO implement
+    }
+
     function processSale(
         NftId bundleNftId, 
-        IPolicy.Premium memory premium 
+        IPolicy.PremiumInfo memory premium 
     ) 
         external
         virtual
         restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         IRegistry registry = getRegistry();
-        IRegistry.ObjectInfo memory bundleObjectInfo = registry.getObjectInfo(bundleNftId);
-        IRegistry.ObjectInfo memory poolObjectInfo = registry.getObjectInfo(bundleObjectInfo.parentNftId);
-        IRegistry.ObjectInfo memory instanceObjectInfo = registry.getObjectInfo(poolObjectInfo.parentNftId);
-        IInstance instance = IInstance(instanceObjectInfo.objectAddress);
+        IRegistry.ObjectInfo memory bundleInfo = registry.getObjectInfo(bundleNftId);
+        IRegistry.ObjectInfo memory poolInfo = registry.getObjectInfo(bundleInfo.parentNftId);
+        IInstance instance = _getInstanceForComponent(registry, poolInfo);
 
-        Amount poolFeeAmount = AmountLib.toAmount(premium.poolFeeFixAmount + premium.poolFeeVarAmount);
-        Amount bundleFeeAmount = AmountLib.toAmount(premium.bundleFeeFixAmount + premium.bundleFeeVarAmount);
-        Amount bundleNetAmount = AmountLib.toAmount(premium.netPremiumAmount);
+        Amount poolFeeAmount = premium.poolFeeFixAmount + premium.poolFeeVarAmount;
+        Amount bundleFeeAmount = premium.bundleFeeFixAmount + premium.bundleFeeVarAmount;
+        Amount bundleNetAmount = premium.netPremiumAmount;
 
         InstanceStore instanceStore = instance.getInstanceStore();
         _componentService.increasePoolBalance(
             instanceStore,
-            poolObjectInfo.nftId,
+            poolInfo.nftId,
             bundleNetAmount + bundleFeeAmount, 
             poolFeeAmount);
 
         _componentService.increaseBundleBalance(
             instanceStore,
-            bundleObjectInfo.nftId,
+            bundleInfo.nftId,
             bundleNetAmount, 
             bundleFeeAmount);
     }
@@ -331,13 +343,17 @@ contract PoolService is
         virtual
         restricted()
         returns (
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         )
     {
+        _checkNftType(productNftId, PRODUCT());
+        _checkNftType(applicationNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+
         (
-            localCollateralAmount,
-            totalCollateralAmount
+            totalCollateralAmount,
+            localCollateralAmount
         ) = calculateRequiredCollateral(
             instance.getInstanceReader(),
             productNftId, 
@@ -355,16 +371,9 @@ contract PoolService is
             instance.getNftId(),
             token,
             totalCollateralAmount);
-
-        // hierarhical riskpool setup
-        // TODO loop in with pool component to guarantee availability of external capital
-        if(totalCollateralAmount > localCollateralAmount) {
-
-        }
     }
 
-
-    function reduceCollateral(
+    function processPayout(
         IInstance instance, 
         address token,
         NftId policyNftId, 
@@ -375,6 +384,24 @@ contract PoolService is
         virtual
         restricted()
     {
+        _checkNftType(policyNftId, POLICY());
+
+        NftId bundleNftId = policyInfo.bundleNftId;
+        NftId poolNftId = getRegistry().getObjectInfo(bundleNftId).parentNftId;
+        InstanceStore instanceStore = instance.getInstanceStore();
+        
+        _componentService.decreasePoolBalance(
+            instanceStore,
+            poolNftId,
+            payoutAmount, 
+            AmountLib.zero());
+
+        _componentService.decreaseBundleBalance(
+            instanceStore,
+            bundleNftId,
+            payoutAmount, 
+            AmountLib.zero());
+
         _bundleService.releaseCollateral(
             instance, 
             policyNftId, 
@@ -401,6 +428,8 @@ contract PoolService is
         virtual
         restricted()
     {
+        _checkNftType(policyNftId, POLICY());
+
         Amount remainingCollateralAmount = policyInfo.sumInsuredAmount - policyInfo.claimAmount;
 
         _bundleService.releaseCollateral(
@@ -429,16 +458,18 @@ contract PoolService is
         public
         view 
         returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         )
     {
+        _checkNftType(productNftId, PRODUCT());
+
         NftId poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
         IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
 
         (
-            localCollateralAmount,
-            totalCollateralAmount
+            totalCollateralAmount,
+            localCollateralAmount
         ) = calculateRequiredCollateral(
             poolInfo.collateralizationLevel,
             poolInfo.retentionLevel,
@@ -454,18 +485,17 @@ contract PoolService is
         public
         pure 
         returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         )
     {
-        // TODO define if only applies to local collateral
-        // TODO add minimalistic implementation
-
-        // assumptions 
-        // - collateralizationLevel == 1.0
-        // - retentionLevel == 1.0
-        localCollateralAmount = sumInsuredAmount;
-        totalCollateralAmount = 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());
     }
 
 
@@ -474,6 +504,7 @@ contract PoolService is
         Amount stakingAmount
     )
         internal
+        pure
         returns (Amount stakingNetAmount)
     {
         stakingNetAmount = stakingAmount;
@@ -488,7 +519,6 @@ contract PoolService is
     }
 
 
-    // TODO create (I)TreasuryService that deals with all gif related token transfers
     /// @dev transfers the specified amount from the bundle owner to the pool's wallet
     function _collectStakingAmount(
         InstanceReader instanceReader,
@@ -501,23 +531,11 @@ contract PoolService is
 
         // collecting investor token
         IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        TokenHandler tokenHandler = componentInfo.tokenHandler;
         address poolWallet = componentInfo.wallet;
-
-        if(amount.gtz()) {
-            uint256 allowance = IERC20Metadata(componentInfo.token).allowance(bundleOwner, address(tokenHandler));
-            if (allowance < amount.toInt()) {
-                revert ErrorPoolServiceWalletAllowanceTooSmall(bundleOwner, address(tokenHandler), allowance, amount.toInt());
-            }
-
-            // TODO: centralize token handling (issue #471)
-            tokenHandler.transfer(
-                bundleOwner,
-                poolWallet,
-                amount);
-        } else {
-            revert ErrorPoolServiceAmountIsZero();
-        }
+        componentInfo.tokenHandler.collectTokens(
+            bundleOwner,
+            poolWallet,
+            amount);
     }
 
     function _getDomain() internal pure override returns(ObjectType) {

package/contracts/pool/PoolServiceManager.sol

@@ -12,14 +12,14 @@ contract PoolServiceManager is ProxyManager {
     /// @dev initializes proxy manager with pool service implementation 
     constructor(
         address authority, 
-        address registryAddress,
+        address registry,
         bytes32 salt
     ) 
-        ProxyManager(registryAddress)
     {
         PoolService poolSrv = new PoolService{salt: salt}();
-        bytes memory data = abi.encode(registryAddress, address(this), authority);
-        IVersionable versionable = deployDetermenistic(
+        bytes memory data = abi.encode(registry, authority);
+        IVersionable versionable = initialize(
+            registry,
             address(poolSrv), 
             data,
             salt);