@etherisc/gif-next 0.0.2-e5a6af8-639 → 0.0.2-e5bdc7a-061

package/contracts/pool/PoolService.sol

@@ -7,28 +7,29 @@ import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
-import {IProductComponent} from "../product/IProductComponent.sol";
+import {IPoolComponent} from "../pool/IPoolComponent.sol";
 import {IPoolService} from "./IPoolService.sol";
+import {IProductComponent} from "../product/IProductComponent.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IStaking} from "../staking/IStaking.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {ClaimId} from "../type/ClaimId.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
 import {Fee, FeeLib} from "../type/Fee.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 {UFixed} from "../type/UFixed.sol";
-import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {Service} from "../shared/Service.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
 
 string constant POOL_SERVICE_NAME = "PoolService";
 
 contract PoolService is 
-    ComponentVerifyingService, 
+    Service, 
     IPoolService 
 {
     IBundleService internal _bundleService;
@@ -63,7 +64,7 @@ contract PoolService is
         external
         virtual
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         InstanceReader instanceReader = instance.getInstanceReader();
         IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
 
@@ -75,39 +76,13 @@ contract PoolService is
     }
 
 
-    /// @inheritdoc IPoolService
-    function createBundle(
-        address bundleOwner, // 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 
-        virtual
-        returns(NftId bundleNftId)
-    {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-
-        // create the empty bundle
-        bundleNftId = _bundleService.create(
-            instance,
-            poolNftId,
-            bundleOwner,
-            fee,
-            AmountLib.zero(), 
-            lifetime,
-            filter);
-
-        emit LogPoolServiceBundleCreated(instance.getNftId(), poolNftId, bundleNftId);
-    }
-
-
     function closeBundle(NftId bundleNftId)
         external
         virtual
-        onlyNftOfType(bundleNftId, BUNDLE())
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
 
         // TODO get performance fee for pool (#477)
 
@@ -125,7 +100,7 @@ contract PoolService is
         if ((unstakedAmount + feeAmount).gtz()){
             IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolNftId);
             poolComponentInfo.tokenHandler.distributeTokens(
-                poolComponentInfo.wallet, 
+                poolComponentInfo.tokenHandler.getWallet(), 
                 getRegistry().ownerOf(bundleNftId), 
                 unstakedAmount + feeAmount);
         }
@@ -140,11 +115,12 @@ contract PoolService is
     ) 
         external
         virtual
-        onlyNftOfType(policyNftId, POLICY())
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        _checkNftType(policyNftId, POLICY());
+
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         InstanceReader instanceReader = instance.getInstanceReader();
-        NftId productNftId = _getProductNftId(poolNftId);
+        NftId productNftId = getRegistry().getObjectInfo(poolNftId).parentNftId;
 
         // check policy matches with calling pool
         IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
@@ -170,10 +146,11 @@ contract PoolService is
         external 
         virtual
         // TODO: restricted() (once #462 is done)
-        onlyNftOfType(bundleNftId, BUNDLE())
         returns(Amount netAmount) 
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         InstanceReader instanceReader = instance.getInstanceReader();
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
         IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
@@ -204,7 +181,7 @@ contract PoolService is
                 amount);
         }
 
-        // do all the bookkeeping
+        // do all the book keeping
         _componentService.increasePoolBalance(
             instance.getInstanceStore(), 
             poolNftId, 
@@ -213,31 +190,36 @@ contract PoolService is
 
         _bundleService.stake(instance, bundleNftId, netAmount);
 
-        // collect tokens from bundle owner
-        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);
+        // only collect staking amount when pool is not externally managed
+        if (!poolInfo.isExternallyManaged) {
+
+            // collect tokens from bundle owner
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            _collectStakingAmount(
+                instanceReader,
+                poolNftId, 
+                bundleOwner, 
+                amount);
+        }
     }
 
+
     /// @inheritdoc IPoolService
     function unstake(NftId bundleNftId, Amount amount) 
         external 
         virtual
-        onlyNftOfType(bundleNftId, BUNDLE())
         // TODO: restricted() (once #462 is done)
         returns(Amount netAmount) 
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         InstanceReader instanceReader = instance.getInstanceReader();
         InstanceStore instanceStore = instance.getInstanceStore();
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
-        
+
         if (bundleInfo.poolNftId != poolNftId) {
             revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
         }
@@ -249,6 +231,7 @@ contract PoolService is
         // if amount was max, this was set to the available amount
 
         // TODO: handle performance fees (issue #477)
+        netAmount = unstakedAmount;
 
         // update pool bookkeeping - performance fees stay in the pool, but as fees 
         _componentService.decreasePoolBalance(
@@ -257,41 +240,77 @@ contract PoolService is
             unstakedAmount, 
             AmountLib.zero());
 
-        IComponents.ComponentInfo memory poolComponentInfo = instanceReader.getComponentInfo(poolNftId);
 
-        // transfer amount to bundle owner
-        address owner = getRegistry().ownerOf(bundleNftId);
-        emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount);
-        poolComponentInfo.tokenHandler.distributeTokens(
-            poolComponentInfo.wallet, 
-            owner, 
-            unstakedAmount);
+        emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount, netAmount);
+
+        // only distribute staking amount when pool is not externally managed
+        if (!instanceReader.getPoolInfo(poolNftId).isExternallyManaged) {
 
-        return unstakedAmount;
+            // transfer amount to bundle owner
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            _distributeUnstakingAmount(
+                instanceReader,
+                poolNftId, 
+                bundleOwner, 
+                netAmount);
+        }
     }
 
 
-    function fundPoolWallet(NftId poolNftId, Amount amount)
+    function fundPoolWallet(Amount amount)
         external
         virtual
-        restricted()
-        onlyNftOfType(poolNftId, POOL())
+        // restricted()
     {
-        // TODO check that poolNftId is externally managed
-        // TODO implement
+        (
+            NftId poolNftId,
+            IInstance instance
+        ) = _getAndVerifyActivePool();
+
+        // check that pool is externally managed
+        InstanceReader reader = instance.getInstanceReader();
+        if (!reader.getPoolInfo(poolNftId).isExternallyManaged) {
+            revert ErrorPoolServicePoolNotExternallyManaged(poolNftId);
+        }
+
+        address poolOwner = getRegistry().ownerOf(poolNftId);
+        emit LogPoolServiceWalletFunded(poolNftId, poolOwner, amount);
+
+        _collectStakingAmount(
+            reader,
+            poolNftId, 
+            poolOwner, 
+            amount);
     }
 
 
-    function defundPoolWallet(NftId poolNftId, Amount amount)
+    function defundPoolWallet(Amount amount)
         external
         virtual
-        restricted()
-        onlyNftOfType(poolNftId, POOL())
+        // restricted()
     {
-        // TODO check that poolNftId is externally managed
-        // TODO implement
+        (
+            NftId poolNftId,
+            IInstance instance
+        ) = _getAndVerifyActivePool();
+
+        // check that pool is externally managed
+        InstanceReader reader = instance.getInstanceReader();
+        if (!reader.getPoolInfo(poolNftId).isExternallyManaged) {
+            revert ErrorPoolServicePoolNotExternallyManaged(poolNftId);
+        }
+
+        address poolOwner = getRegistry().ownerOf(poolNftId);
+        emit LogPoolServiceWalletDefunded(poolNftId, poolOwner, amount);
+
+        _distributeUnstakingAmount(
+            reader,
+            poolNftId, 
+            poolOwner, 
+            amount);
     }
 
+
     function processSale(
         NftId bundleNftId, 
         IPolicy.PremiumInfo memory premium 
@@ -299,12 +318,13 @@ contract PoolService is
         external
         virtual
         restricted()
-        onlyNftOfType(bundleNftId, BUNDLE())
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         IRegistry registry = getRegistry();
-        IRegistry.ObjectInfo memory bundleInfo = registry.getObjectInfo(bundleNftId);
-        IRegistry.ObjectInfo memory poolInfo = registry.getObjectInfo(bundleInfo.parentNftId);
-        IInstance instance = _getInstanceForComponent(registry, poolInfo);
+        NftId poolNftId = registry.getObjectInfo(bundleNftId).parentNftId;
+        (, address instanceAddress) = ContractLib.getInfoAndInstance(registry, poolNftId, true);
+        IInstance instance = IInstance(instanceAddress);
 
         Amount poolFeeAmount = premium.poolFeeFixAmount + premium.poolFeeVarAmount;
         Amount bundleFeeAmount = premium.bundleFeeFixAmount + premium.bundleFeeVarAmount;
@@ -313,13 +333,13 @@ contract PoolService is
         InstanceStore instanceStore = instance.getInstanceStore();
         _componentService.increasePoolBalance(
             instanceStore,
-            poolInfo.nftId,
+            poolNftId,
             bundleNetAmount + bundleFeeAmount, 
             poolFeeAmount);
 
         _componentService.increaseBundleBalance(
             instanceStore,
-            bundleInfo.nftId,
+            bundleNftId,
             bundleNetAmount, 
             bundleFeeAmount);
     }
@@ -336,17 +356,22 @@ contract PoolService is
         external
         virtual
         restricted()
-        onlyNftOfType(productNftId, PRODUCT())
-        onlyNftOfType(applicationNftId, POLICY())
-        onlyNftOfType(bundleNftId, BUNDLE())
         returns (
             Amount totalCollateralAmount,
             Amount localCollateralAmount
         )
     {
+        _checkNftType(productNftId, PRODUCT());
+        _checkNftType(applicationNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        NftId poolNftId;
+        bool poolIsVerifyingApplications;
         (
+            poolNftId,
             totalCollateralAmount,
-            localCollateralAmount
+            localCollateralAmount,
+            poolIsVerifyingApplications
         ) = calculateRequiredCollateral(
             instance.getInstanceReader(),
             productNftId, 
@@ -364,6 +389,21 @@ contract PoolService is
             instance.getNftId(),
             token,
             totalCollateralAmount);
+
+        // pool callback when required
+        if (poolIsVerifyingApplications) {
+            IPoolComponent pool = IPoolComponent(
+                getRegistry().getObjectAddress(poolNftId));
+
+            pool.verifyApplication(
+                applicationNftId, 
+                bundleNftId, 
+                totalCollateralAmount);
+
+            // TODO add logging
+        }
+
+        // TODO add logging
     }
 
     function processPayout(
@@ -376,8 +416,9 @@ contract PoolService is
         external
         virtual
         restricted()
-        onlyNftOfType(policyNftId, POLICY())
     {
+        _checkNftType(policyNftId, POLICY());
+
         NftId bundleNftId = policyInfo.bundleNftId;
         NftId poolNftId = getRegistry().getObjectInfo(bundleNftId).parentNftId;
         InstanceStore instanceStore = instance.getInstanceStore();
@@ -419,8 +460,9 @@ contract PoolService is
         external
         virtual
         restricted()
-        onlyNftOfType(policyNftId, POLICY())
     {
+        _checkNftType(policyNftId, POLICY());
+
         Amount remainingCollateralAmount = policyInfo.sumInsuredAmount - policyInfo.claimAmount;
 
         _bundleService.releaseCollateral(
@@ -429,10 +471,6 @@ contract PoolService is
             policyInfo.bundleNftId, 
             remainingCollateralAmount);
 
-        _bundleService.unlinkPolicy(
-            instance, 
-            policyNftId);
-
         // update value locked with staking service
         _staking.decreaseTotalValueLocked(
             instance.getNftId(),
@@ -448,14 +486,18 @@ contract PoolService is
     )
         public
         view 
-        onlyNftOfType(productNftId, PRODUCT())
         returns(
+            NftId poolNftId,
             Amount totalCollateralAmount,
-            Amount localCollateralAmount
+            Amount localCollateralAmount,
+            bool poolIsVerifyingApplications
         )
     {
-        NftId poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
+        _checkNftType(productNftId, PRODUCT());
+
+        poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
         IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+        poolIsVerifyingApplications = poolInfo.isVerifyingApplications;
 
         (
             totalCollateralAmount,
@@ -509,25 +551,61 @@ contract PoolService is
     }
 
 
-    /// @dev transfers the specified amount from the bundle owner to the pool's wallet
+    /// @dev transfers the specified amount from the "from account" to the pool's wallet
     function _collectStakingAmount(
-        InstanceReader instanceReader,
+        InstanceReader reader,
         NftId poolNftId,
-        address bundleOwner,
+        address from,
         Amount amount
     )
         internal
     {
+        IComponents.ComponentInfo memory info = reader.getComponentInfo(poolNftId);
+        info.tokenHandler.collectTokens(
+            from,
+            amount);
+    }
 
-        // collecting investor token
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        address poolWallet = componentInfo.wallet;
-        componentInfo.tokenHandler.collectTokens(
-            bundleOwner,
-            poolWallet,
+    /// @dev distributes the specified amount from the pool's wallet to the "to account"
+    function _distributeUnstakingAmount(
+        InstanceReader reader,
+        NftId poolNftId,
+        address to,
+        Amount amount
+    )
+        internal
+    {
+        IComponents.ComponentInfo memory info = reader.getComponentInfo(poolNftId);
+        info.tokenHandler.distributeTokens(
+            info.tokenHandler.getWallet(), 
+            to, 
             amount);
     }
 
+
+    function _getAndVerifyActivePool()
+        internal
+        virtual
+        view
+        returns (
+            NftId poolNftId,
+            IInstance instance
+        )
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyComponent(
+            getRegistry(), 
+            msg.sender,
+            POOL(),
+            true); // only active pools
+
+        poolNftId = info.nftId;
+        instance = IInstance(instanceAddress);
+    }
+
+
     function _getDomain() internal pure override returns(ObjectType) {
         return POOL();
     }

package/contracts/product/ApplicationService.sol

@@ -55,10 +55,10 @@ contract ApplicationService is
     }
 
 
-    function _checkLinkedpplicationParameters(
+    function _checkLinkedApplicationParameters(
         InstanceReader instanceReader,
         NftId productNftId,
-        RiskId rirskId,
+        RiskId riskId,
         ReferralId referralId,
         NftId bundleNftId
     )
@@ -66,18 +66,18 @@ contract ApplicationService is
         virtual
         view
     {
-        IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
+        // check risk with product
+        (bool exists, bool active) = instanceReader.getRiskSet().checkRisk(productNftId, riskId);
+        if (!exists) { revert ErrorApplicationServiceRiskUnknown(riskId, productNftId); }
+        if (!active) { revert ErrorApplicationServiceRiskPaused(riskId, productNftId); }
 
-        // TODO check riskId with product
+        // check bundle with pool
+        NftId poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
+        (exists, active) = instanceReader.getBundleSet().checkBundle(poolNftId, bundleNftId);
+        if (!exists) { revert ErrorApplicationServiceBundleUnknown(bundleNftId, poolNftId); }
+        if (!active) { revert ErrorApplicationServiceBundleLocked(bundleNftId, poolNftId); }
 
         // TODO check referral with distribution
-
-        // check bundle with pool
-        NftId productPoolNftId = productInfo.poolNftId;
-        NftId bundlePoolNftId = instanceReader.getBundleInfo(bundleNftId).poolNftId;
-        if(bundlePoolNftId != productPoolNftId) {
-            revert ErrorApplicationServiceBundlePoolMismatch(bundleNftId, productPoolNftId, bundlePoolNftId);
-        }
     }
 
 
@@ -135,14 +135,15 @@ contract ApplicationService is
         external
         virtual
         nonReentrant()
-        onlyNftOfType(bundleNftId, BUNDLE())
         returns (NftId applicationNftId)
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         (NftId productNftId,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
 
         // check if provided references are valid and linked to calling product contract
         InstanceReader instanceReader = instance.getInstanceReader();
-        _checkLinkedpplicationParameters(
+        _checkLinkedApplicationParameters(
             instanceReader,
             productNftId,
             riskId,
@@ -212,10 +213,10 @@ contract ApplicationService is
         external
         virtual
         nonReentrant()
-        onlyNftOfType(policyNftId, POLICY())
-        onlyNftOfType(bundleNftId, BUNDLE())
         returns (NftId applicationNftId)
     {
+        _checkNftType(policyNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
         // TODO implement
     }
 
@@ -232,9 +233,9 @@ contract ApplicationService is
         external
         virtual
         nonReentrant()
-        onlyNftOfType(applicationNftId, POLICY())
-        onlyNftOfType(bundleNftId, BUNDLE())
     {
+        _checkNftType(applicationNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
         // TODO implement
     }
 
@@ -242,8 +243,9 @@ contract ApplicationService is
         external
         virtual
         nonReentrant()
-        onlyNftOfType(applicationNftId, POLICY())
     {
+        _checkNftType(applicationNftId, POLICY());
+
         (,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
         instance.getInstanceStore().updateApplicationState(applicationNftId, REVOKED());
     }

package/contracts/product/BasicProduct.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.20;
 
 import {Fee} from "../type/Fee.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
 import {NftId} from "../type/NftId.sol";
 import {Product} from "../product/Product.sol";
 
@@ -25,13 +26,11 @@ abstract contract BasicProduct is
     function _initializeBasicProduct(
         address registry,
         NftId instanceNftId,
-        IAuthorization authorization,
-        address initialOwner,
         string memory name,
         address token,
-        bool isInterceptor,
-        bool hasDistribution,
-        uint8 numberOfOracles
+        IComponents.ProductInfo memory productInfo,
+        IAuthorization authorization,
+        address initialOwner
     )
         internal
         virtual
@@ -40,14 +39,11 @@ abstract contract BasicProduct is
         _initializeProduct(
             registry, 
             instanceNftId, 
-            authorization, 
-            initialOwner, 
             name, 
             token, 
-            isInterceptor, 
-            false, // is processing funded claims
-            hasDistribution,
-            numberOfOracles,
+            productInfo,
+            authorization, 
+            initialOwner, 
             ""); // component data
     }
 }