@etherisc/gif-next 3.0.0-2e16ebd-614 → 3.0.0-303db9f-884

package/contracts/pool/IPoolService.sol

@@ -18,14 +18,15 @@ interface IPoolService is IService {
     event LogPoolServiceWalletFunded(NftId poolNftId, address poolOwner, Amount amount);
     event LogPoolServiceWalletDefunded(NftId poolNftId, address poolOwner, Amount amount);
 
-    event LogPoolServiceBundleClosed(NftId poolNftId, NftId bundleNftId);
+    event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+    event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount balanceAmount, Amount feeAmount);
 
-    event LogPoolServiceBundleStaked(NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
-    event LogPoolServiceBundleUnstaked(NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+    event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
 
-    event LogPoolServiceFeesWithdrawn(NftId poolNftId, NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
+    event LogPoolServiceFeesWithdrawn(NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
 
-    event LogPoolServiceProcessFundedClaim(NftId poolNftId, NftId policyNftId, ClaimId claimId, Amount availableAmount);
+    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);

package/contracts/pool/Pool.sol

@@ -35,7 +35,7 @@ abstract contract Pool is
 
 
     modifier onlyBundleOwner(NftId bundleNftId) {
-        if(msg.sender != _getRegistry().ownerOf(bundleNftId)) {
+        if(msg.sender != getRegistry().ownerOf(bundleNftId)) {
             revert ErrorPoolNotBundleOwner(bundleNftId, msg.sender);
         }
         _;
@@ -124,6 +124,7 @@ abstract contract Pool is
     // Internals
 
     function __Pool_init(
+        address registry,
         NftId productNftId,
         string memory name,
         IComponents.PoolInfo memory poolInfo,
@@ -135,6 +136,7 @@ abstract contract Pool is
         onlyInitializing()
     {
         __InstanceLinkedComponent_init(
+            registry, 
             productNftId,  
             name, 
             POOL(), 

package/contracts/pool/PoolLib.sol

@@ -18,7 +18,6 @@ import {ObjectType, BUNDLE, POOL} from "../type/ObjectType.sol";
 import {PayoutId} from "../type/PayoutId.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {UFixed} from "../type/UFixed.sol";
-import {VersionPart} from "../type/Version.sol";
 
 library PoolLib {
 
@@ -77,6 +76,7 @@ library PoolLib {
 
 
     function calculateStakingAmounts(
+        IRegistry registry,
         InstanceReader instanceReader,
         NftId poolNftId,
         Amount stakingAmount
@@ -88,7 +88,7 @@ library PoolLib {
             Amount netStakingAmount
         )
     {
-        NftId productNftId = ContractLib.getRegistry().getParentNftId(poolNftId);
+        NftId productNftId = registry.getParentNftId(poolNftId);
         Fee memory stakingFee = instanceReader.getFeeInfo(productNftId).stakingFee;
         (
             feeAmount,
@@ -100,6 +100,7 @@ library PoolLib {
 
 
     function calculatePayoutAmounts(
+        IRegistry registry,
         InstanceReader instanceReader,
         NftId productNftId,
         NftId policyNftId,
@@ -120,7 +121,7 @@ library PoolLib {
             netPayoutAmount = payoutAmount;
 
             if (payoutBeneficiary == address(0)) {
-                beneficiary = ContractLib.getRegistry().ownerOf(policyNftId);
+                beneficiary = registry.ownerOf(policyNftId);
             } else { 
                 beneficiary = payoutBeneficiary;
             }
@@ -135,13 +136,14 @@ library PoolLib {
 
 
     function getPolicyHolder(
+        IRegistry registry, 
         NftId policyNftId
     )
         internal 
         view 
         returns (IPolicyHolder policyHolder)
     {
-        address policyHolderAddress = ContractLib.getRegistry().ownerOf(policyNftId);
+        address policyHolderAddress = registry.ownerOf(policyNftId);
         policyHolder = IPolicyHolder(policyHolderAddress);
 
         if (!ContractLib.isPolicyHolder(policyHolderAddress)) {
@@ -149,7 +151,99 @@ library PoolLib {
         }
     }
 
+
+    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 getAndVerifyActiveComponent(
+        IRegistry registry,
+        address sender,
+        ObjectType expectedComponentType
+    )
+        public
+        view
+        returns (
+            NftId componentNftId,
+            IInstance instance
+        )
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyComponent(
+            registry, 
+            sender,
+            expectedComponentType,
+            true); // only active components
+
+        componentNftId = 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);
+        }
+    }
+
     function transferTokenAndNotifyPolicyHolder(
+        IRegistry registry,
         InstanceReader instanceReader,
         TokenHandler poolTokenHandler,
         NftId productNftId,
@@ -171,6 +265,7 @@ library PoolLib {
             processingFeeAmount,
             beneficiary
         ) = calculatePayoutAmounts(
+            registry,
             instanceReader,
             productNftId, 
             policyNftId,
@@ -192,6 +287,7 @@ library PoolLib {
 
         // callback to policy holder if applicable
         policyHolderPayoutExecuted(
+            registry,
             policyNftId, 
             payoutId, 
             beneficiary, 
@@ -199,6 +295,7 @@ library PoolLib {
     }
 
     function policyHolderPayoutExecuted(
+        IRegistry registry,
         NftId policyNftId, 
         PayoutId payoutId,
         address beneficiary,
@@ -206,7 +303,7 @@ library PoolLib {
     )
         private
     {
-        IPolicyHolder policyHolder = getPolicyHolder(policyNftId);
+        IPolicyHolder policyHolder = getPolicyHolder(registry, policyNftId);
         if(address(policyHolder) != address(0)) {
             policyHolder.payoutExecuted(policyNftId, payoutId, payoutAmount, beneficiary);
         }

package/contracts/pool/PoolService.sol

@@ -42,18 +42,19 @@ contract PoolService is
     )
         internal
         virtual override
-        onlyInitializing()
+        initializer()
     {
         (
-            address authority
-        ) = abi.decode(data, (address));
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
 
-        __Service_init(authority, owner);
+        __Service_init(authority, registry, owner);
 
         _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
         _bundleService = IBundleService(_getServiceAddress(BUNDLE()));
         _componentService = IComponentService(_getServiceAddress(COMPONENT()));
-        _staking = IStaking(_getRegistry().getStakingAddress());
+        _staking = IStaking(getRegistry().getStakingAddress());
 
         _registerInterface(type(IPoolService).interfaceId);
     }
@@ -65,11 +66,7 @@ contract PoolService is
         virtual
         restricted()
     {
-        (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPool(getRelease());
-
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         InstanceReader instanceReader = instance.getInstanceReader();
         IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
 
@@ -81,20 +78,15 @@ contract PoolService is
     }
 
 
-    // TODO closing bundle here but creating in bundle service
     function closeBundle(NftId bundleNftId)
         external
         restricted()
         virtual
     {
-        // checks
-        (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPoolForBundle(
-            bundleNftId, getRelease());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
 
-        // effects
         // TODO get performance fee for pool (#477)
 
         // releasing collateral in bundle
@@ -103,15 +95,15 @@ contract PoolService is
         _accountingService.decreasePoolBalance(
             instance.getInstanceStore(), 
             poolNftId, 
-            unstakedAmount + feeAmount, 
+            unstakedAmount +  feeAmount, 
             AmountLib.zero());
         
-        emit LogPoolServiceBundleClosed(poolNftId, bundleNftId);
+        emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount, feeAmount);
 
-        if ((unstakedAmount + feeAmount).gtz()) {
-            TokenHandler tokenHandler = instance.getInstanceReader().getTokenHandler(poolNftId);
-            tokenHandler.pushToken(
-                _getRegistry().ownerOf(bundleNftId), 
+        if ((unstakedAmount + feeAmount).gtz()){
+            IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolNftId);
+            poolComponentInfo.tokenHandler.pushToken(
+                getRegistry().ownerOf(bundleNftId), 
                 unstakedAmount + feeAmount);
         }
     }
@@ -127,25 +119,56 @@ contract PoolService is
         restricted()
         virtual
     {
-        (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPoolForPolicy(
-            policyNftId, getRelease());
+        _checkNftType(policyNftId, POLICY());
 
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         InstanceReader instanceReader = instance.getInstanceReader();
-        NftId productNftId = _getRegistry().getParentNftId(poolNftId);
+        NftId productNftId = getRegistry().getParentNftId(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(poolNftId, policyNftId, claimId, availableAmount);
+        emit LogPoolServiceProcessFundedClaim(policyNftId, claimId, availableAmount);
 
-        // TODO reading the whole struct for just 1 check
         // callback to product component if applicable
         if (instanceReader.getProductInfo(productNftId).isProcessingFundedClaims) {
-            address productAddress = _getRegistry().getObjectAddress(productNftId);
+            address productAddress = getRegistry().getObjectAddress(productNftId);
             IProductComponent(productAddress).processFundedClaim(policyNftId, claimId, availableAmount);
         }
     }
 
+
+    // function _checkAndGetPoolInfo(NftId bundleNftId)
+    //     internal
+    //     view
+    //     returns (
+    //         InstanceReader instanceReader,
+    //         InstanceStore instanceStore,
+    //         NftId instanceNftId,
+    //         NftId poolNftId,
+    //         IComponents.PoolInfo memory poolInfo
+    //     )
+    // {
+    //     _checkNftType(bundleNftId, BUNDLE());
+
+    //     (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
+    //     instanceReader = instance.getInstanceReader();
+    //     instanceStore = instance.getInstanceStore();
+    //     instanceNftId = instance.getNftId();
+    //     poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+    //     if (getRegistry().getParentNftId(bundleNftId) != poolNftId) {
+    //         revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+    //     }
+    // }
+
+
     /// @inheritdoc IPoolService
     function stake(NftId bundleNftId, Amount amount) 
         external 
@@ -156,14 +179,12 @@ contract PoolService is
         ) 
     {
         (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPoolForBundle(
-            bundleNftId, getRelease());
-
-        InstanceReader instanceReader = instance.getInstanceReader();
-        InstanceStore instanceStore = instance.getInstanceStore();
-        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+            InstanceReader instanceReader,
+            InstanceStore instanceStore,
+            NftId instanceNftId,
+            NftId poolNftId,
+            IComponents.PoolInfo memory poolInfo
+        ) = PoolLib.checkAndGetPoolInfo(getRegistry(), msg.sender, bundleNftId);
 
         {
             Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
@@ -178,6 +199,7 @@ contract PoolService is
             feeAmount,
             netAmount
         ) = PoolLib.calculateStakingAmounts(
+            getRegistry(),
             instanceReader,
             poolNftId,
             amount);
@@ -191,13 +213,13 @@ contract PoolService is
 
         _bundleService.stake(instanceReader, instanceStore, bundleNftId, netAmount);
 
-        emit LogPoolServiceBundleStaked(poolNftId, bundleNftId, amount, netAmount);
+        emit LogPoolServiceBundleStaked(instanceNftId, poolNftId, bundleNftId, amount, netAmount);
 
         // only collect staking amount when pool is not externally managed
         if (!poolInfo.isExternallyManaged) {
 
             // collect tokens from bundle owner
-            address bundleOwner = _getRegistry().ownerOf(bundleNftId);
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
             PoolLib.pullStakingAmount(
                 instanceReader,
                 poolNftId, 
@@ -215,13 +237,11 @@ contract PoolService is
         returns(Amount netAmount) 
     {
         (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPoolForBundle(
-            bundleNftId, getRelease());
-
-        InstanceReader instanceReader = instance.getInstanceReader();
-        InstanceStore instanceStore = instance.getInstanceStore();
+            InstanceReader instanceReader,
+            InstanceStore instanceStore,
+            NftId instanceNftId,
+            NftId poolNftId,
+        ) = PoolLib.checkAndGetPoolInfo(getRegistry(), msg.sender, bundleNftId);
 
         // call bundle service for bookkeeping and additional checks
         Amount unstakedAmount = _bundleService.unstake(instanceStore, bundleNftId, amount);
@@ -240,13 +260,13 @@ contract PoolService is
             AmountLib.zero());
 
 
-        emit LogPoolServiceBundleUnstaked(poolNftId, bundleNftId, unstakedAmount, netAmount);
+        emit LogPoolServiceBundleUnstaked(instanceNftId, poolNftId, bundleNftId, unstakedAmount, netAmount);
 
         // only distribute staking amount when pool is not externally managed
         if (!instanceReader.getPoolInfo(poolNftId).isExternallyManaged) {
 
             // transfer amount to bundle owner
-            address bundleOwner = _getRegistry().ownerOf(bundleNftId);
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
             PoolLib.pushUnstakingAmount(
                 instanceReader,
                 poolNftId, 
@@ -264,7 +284,7 @@ contract PoolService is
         (
             NftId poolNftId,
             IInstance instance
-        ) = ContractLib.getAndVerifyPool(getRelease());
+        ) = _getAndVerifyActivePool();
 
         // check that pool is externally managed
         InstanceReader reader = instance.getInstanceReader();
@@ -272,7 +292,7 @@ contract PoolService is
             revert ErrorPoolServicePoolNotExternallyManaged(poolNftId);
         }
 
-        address poolOwner = _getRegistry().ownerOf(poolNftId);
+        address poolOwner = getRegistry().ownerOf(poolNftId);
         emit LogPoolServiceWalletFunded(poolNftId, poolOwner, amount);
 
         PoolLib.pullStakingAmount(
@@ -291,7 +311,7 @@ contract PoolService is
         (
             NftId poolNftId,
             IInstance instance
-        ) = ContractLib.getAndVerifyPool(getRelease());
+        ) = _getAndVerifyActivePool();
 
         // check that pool is externally managed
         InstanceReader reader = instance.getInstanceReader();
@@ -299,7 +319,7 @@ contract PoolService is
             revert ErrorPoolServicePoolNotExternallyManaged(poolNftId);
         }
 
-        address poolOwner = _getRegistry().ownerOf(poolNftId);
+        address poolOwner = getRegistry().ownerOf(poolNftId);
         emit LogPoolServiceWalletDefunded(poolNftId, poolOwner, amount);
 
         PoolLib.pushUnstakingAmount(
@@ -320,8 +340,10 @@ contract PoolService is
     {
         _checkNftType(bundleNftId, BUNDLE());
 
-        NftId poolNftId = _getRegistry().getParentNftId(bundleNftId);
-        (, IInstance instance) = ContractLib.getInfoAndInstance(poolNftId, getRelease(), true);
+        IRegistry registry = getRegistry();
+        NftId poolNftId = registry.getParentNftId(bundleNftId);
+        (, address instanceAddress) = ContractLib.getInfoAndInstance(registry, poolNftId, true);
+        IInstance instance = IInstance(instanceAddress);
 
         Amount poolFeeAmount = premium.poolFeeFixAmount + premium.poolFeeVarAmount;
         Amount bundleFeeAmount = premium.bundleFeeFixAmount + premium.bundleFeeVarAmount;
@@ -392,7 +414,7 @@ contract PoolService is
         // pool callback when required
         if (poolIsVerifyingApplications) {
             IPoolComponent pool = IPoolComponent(
-                _getRegistry().getObjectAddress(poolNftId));
+                getRegistry().getObjectAddress(poolNftId));
 
             pool.verifyApplication(
                 applicationNftId, 
@@ -432,7 +454,7 @@ contract PoolService is
         _checkNftType(policyNftId, POLICY());
 
         // effects
-        NftId poolNftId = _getRegistry().getParentNftId(bundleNftId);
+        NftId poolNftId = getRegistry().getParentNftId(bundleNftId);
         
         _accountingService.decreasePoolBalance(
             instanceStore,
@@ -462,6 +484,7 @@ contract PoolService is
 
         // interactions
         (netPayoutAmount, processingFeeAmount) = PoolLib.transferTokenAndNotifyPolicyHolder(
+            getRegistry(),
             instanceReader, 
             poolTokenHandler,
             productNftId, 
@@ -499,12 +522,9 @@ contract PoolService is
         returns (Amount withdrawnAmount) 
     {
         // checks
-        (
-            NftId poolNftId, 
-            IInstance instance
-        ) = ContractLib.getAndVerifyPoolForBundle(
-            bundleNftId, getRelease());
+        _checkNftType(bundleNftId, BUNDLE());
 
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         InstanceReader reader = instance.getInstanceReader();
         
         // determine withdrawn amount
@@ -530,10 +550,10 @@ contract PoolService is
         // interactions
         // transfer amount to bundle owner
         {
-            address bundleOwner = _getRegistry().ownerOf(bundleNftId);
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
             TokenHandler tokenHandler = reader.getTokenHandler(poolNftId);
             address token = address(tokenHandler.TOKEN());
-            emit LogPoolServiceFeesWithdrawn(poolNftId, bundleNftId, bundleOwner, token, withdrawnAmount);
+            emit LogPoolServiceFeesWithdrawn(bundleNftId, bundleOwner, token, withdrawnAmount);
 
             tokenHandler.pushToken(bundleOwner, withdrawnAmount);
         }
@@ -574,6 +594,20 @@ contract PoolService is
             remainingCollateralAmount);
     }
 
+
+    function _getAndVerifyActivePool()
+        internal
+        virtual
+        view
+        returns (
+            NftId poolNftId,
+            IInstance instance
+        )
+    {
+        return PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
+    }
+
+
     function _getDomain() internal pure override returns(ObjectType) {
         return POOL();
     }

package/contracts/pool/PoolServiceManager.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IUpgradeable} from "../upgradeability/IUpgradeable.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
 import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {PoolService} from "./PoolService.sol";
 
@@ -12,17 +12,19 @@ contract PoolServiceManager is ProxyManager {
     /// @dev initializes proxy manager with pool service implementation 
     constructor(
         address authority, 
+        address registry,
         bytes32 salt
     ) 
     {
         PoolService poolSrv = new PoolService{salt: salt}();
-        bytes memory data = abi.encode(authority);
-        IUpgradeable upgradeable = initialize(
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
             address(poolSrv), 
             data,
             salt);
 
-        _poolService = PoolService(address(upgradeable));
+        _poolService = PoolService(address(versionable));
     }
 
     //--- view functions ----------------------------------------------------//