@etherisc/gif-next 0.0.2-708facd-459 → 0.0.2-70b1050-183

package/contracts/pool/Pool.sol

@@ -14,6 +14,7 @@ import {Fee, FeeLib} from "../type/Fee.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {UFixed, UFixedLib} from "../type/UFixed.sol";
 
@@ -91,6 +92,18 @@ abstract contract Pool is
         onlyOwner()
     {
         _getPoolStorage()._componentService.registerPool();
+        _approveTokenHandler(type(uint256).max);
+    }
+
+    /// @inheritdoc IPoolComponent
+    function withdrawBundleFees(NftId bundleNftId, Amount amount) 
+        external 
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+        returns (Amount withdrawnAmount) 
+    {
+        return _withdrawBundleFees(bundleNftId, amount);
     }
 
 
@@ -100,19 +113,15 @@ abstract contract Pool is
         view 
         returns (IComponents.PoolInfo memory poolInfo)
     {
-        return IComponents.PoolInfo(
-            NftIdLib.zero(), // will be set when GIF registers the related product
-            PUBLIC_ROLE(), // bundleOwnerRole
-            AmountLib.max(), // maxCapitalAmount,
-            isNftInterceptor(), // isInterceptingBundleTransfers
-            false, // isExternallyManaged,
-            false, // isVerifyingApplications,
-            UFixedLib.toUFixed(1), // collateralizationLevel,
-            UFixedLib.toUFixed(1), // retentionLevel,
-            FeeLib.zero(), // initialPoolFee,
-            FeeLib.zero(), // initialStakingFee,
-            FeeLib.zero() // initialPerformanceFee,
-        );
+        return IComponents.PoolInfo({
+            maxBalanceAmount: AmountLib.max(),
+            bundleOwnerRole: PUBLIC_ROLE(), 
+            isInterceptingBundleTransfers: isNftInterceptor(),
+            isExternallyManaged: false,
+            isVerifyingApplications: false,
+            collateralizationLevel: UFixedLib.toUFixed(1),
+            retentionLevel: UFixedLib.toUFixed(1)
+        });
     }
 
     // Internals
@@ -149,7 +158,7 @@ abstract contract Pool is
         $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
         $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
 
-        registerInterface(type(IPoolComponent).interfaceId);
+        _registerInterface(type(IPoolComponent).interfaceId);
     }
 
     /// @dev increases the staked tokens by the specified amount
@@ -160,8 +169,9 @@ abstract contract Pool is
     )
         internal
         virtual
+        returns(Amount) 
     {
-        // TODO add implementation
+        return _getPoolStorage()._poolService.stake(bundleNftId, amount);
     }
 
 
@@ -173,8 +183,9 @@ abstract contract Pool is
     )
         internal
         virtual
+        returns(Amount netAmount) 
     {
-        // TODO add implementation
+        return _getPoolStorage()._poolService.unstake(bundleNftId, amount);
     }
 
 
@@ -186,8 +197,9 @@ abstract contract Pool is
     )
         internal
         virtual
+        returns (Timestamp extendedExpiredAt) 
     {
-        // TODO add implementation
+        return _getPoolStorage()._bundleService.extend(bundleNftId, lifetimeExtension);
     }
 
 
@@ -217,7 +229,7 @@ abstract contract Pool is
     /// To close a bundle all all linked policies MUST be in closed state as well.
     /// Closing a bundle finalizes the bundle bookkeeping including overall profit calculation.
     /// Once a bundle is closed this action cannot be reversed.
-    function _close(NftId bundleNftId)
+    function _closeBundle(NftId bundleNftId)
         internal
         virtual
     {
@@ -239,13 +251,13 @@ abstract contract Pool is
     }
 
 
-    /// @dev Sets the maximum overall capital amound held by this pool.
+    /// @dev Sets the maximum balance amound held by this pool.
     /// Function may only be called by pool owner.
-    function _setMaxCapitalAmount(Amount maxCapitalAmount)
+    function _setMaxBalanceAmount(Amount maxBalanceAmount)
         internal
         virtual
     {
-        _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
+        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
     }
 
     /// @dev Sets the required role to create/own bundles.
@@ -275,11 +287,10 @@ abstract contract Pool is
         _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
     }
 
-    /// @dev Creates a new bundle using the provided parameter values.
+    /// @dev Creates a new empty bundle using the provided parameter values.
     function _createBundle(
         address bundleOwner,
         Fee memory fee,
-        Amount amount,
         Seconds lifetime, 
         bytes memory filter
     )
@@ -289,19 +300,23 @@ abstract contract Pool is
         bundleNftId = _getPoolStorage()._poolService.createBundle(
             bundleOwner,
             fee,
-            amount,
             lifetime,
             filter);
 
         // TODO add logging
     }
 
-
     // TODO remove function once this is no longer used to produce contract locations on the fly ...
     function getContractLocation(bytes memory name) external pure returns (bytes32 hash) {
         return keccak256(abi.encode(uint256(keccak256(name)) - 1)) & ~bytes32(uint256(0xff));
     }
 
+    function _withdrawBundleFees(NftId bundleNftId, Amount amount) 
+        internal
+        returns (Amount withdrawnAmount) 
+    {
+        return _getPoolStorage()._bundleService.withdrawBundleFees(bundleNftId, amount);
+    }
 
     function _getPoolStorage() private pure returns (PoolStorage storage $) {
         assembly {

package/contracts/pool/PoolService.sol

@@ -1,45 +1,30 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Pool} from "./Pool.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {IInstance} from "../instance/IInstance.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 {IVersionable} from "../shared/IVersionable.sol";
-import {Versionable} from "../shared/Versionable.sol";
-import {INftOwnable} from "../shared/INftOwnable.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 {Fee, FeeLib} from "../type/Fee.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY, STAKING} from "../type/ObjectType.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY} from "../type/ObjectType.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
-import {Version, VersionLib} from "../type/Version.sol";
-import {KEEP_STATE, StateId} from "../type/StateId.sol";
+import {KEEP_STATE} from "../type/StateId.sol";
 import {Seconds} from "../type/Seconds.sol";
-import {TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
 import {UFixed} from "../type/UFixed.sol";
-import {Version, VersionLib} from "../type/Version.sol";
-
-import {IService} from "../shared/IService.sol";
-import {Service} from "../shared/Service.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {IBundleService} from "./IBundleService.sol";
-import {IComponentService} from "../shared/IComponentService.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
-import {IPoolService} from "./IPoolService.sol";
-import {IRegistryService} from "../registry/IRegistryService.sol";
-import {IStaking} from "../staking/IStaking.sol";
-import {InstanceService} from "../instance/InstanceService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
-import {IComponent} from "../shared/IComponent.sol";
-import {IPoolComponent} from "./IPoolComponent.sol";
 
 string constant POOL_SERVICE_NAME = "PoolService";
 
@@ -47,9 +32,6 @@ contract PoolService is
     ComponentVerifyingService, 
     IPoolService 
 {
-    using NftIdLib for NftId;
-    using AmountLib for Amount;
-
     IBundleService internal _bundleService;
     IComponentService internal _componentService;
     IInstanceService private _instanceService;
@@ -62,16 +44,15 @@ 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()));
@@ -80,27 +61,23 @@ contract PoolService is
 
         _staking = IStaking(getRegistry().getStakingAddress());
 
-        registerInterface(type(IPoolService).interfaceId);
+        _registerInterface(type(IPoolService).interfaceId);
     }
 
-
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
+    /// @inheritdoc IPoolService
+    function setMaxBalanceAmount(Amount maxBalanceAmount)
         external
         virtual
     {
-        /*
         (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 previousMaxCapitalAmount = poolInfo.maxCapitalAmount;
-
-        poolInfo.maxCapitalAmount = maxCapitalAmount;
+        Amount previousMaxBalanceAmount = poolInfo.maxBalanceAmount;
+        poolInfo.maxBalanceAmount = maxBalanceAmount;
         instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
 
-        emit LogPoolServiceMaxCapitalAmountUpdated(poolNftId, previousMaxCapitalAmount, maxCapitalAmount);
-        */
+        emit LogPoolServiceMaxBalanceAmountUpdated(poolNftId, previousMaxBalanceAmount, maxBalanceAmount);
     }
 
     function setBundleOwnerRole(RoleId bundleOwnerRole)
@@ -124,31 +101,10 @@ contract PoolService is
         emit LogPoolServiceBundleOwnerRoleSet(poolNftId, bundleOwnerRole);
     }
 
-
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    )
-        external
-        virtual
-    {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-
-        IComponents.PoolInfo memory poolInfo = instance.getInstanceReader().getPoolInfo(poolNftId);
-        poolInfo.poolFee = poolFee;
-        poolInfo.stakingFee = stakingFee;
-        poolInfo.performanceFee = performanceFee;
-
-        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
-
-        // TODO add logging
-    }
-
+    /// @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
     )
@@ -157,38 +113,17 @@ contract PoolService is
         returns(NftId bundleNftId)
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
-
-        (
-            Amount stakingFeeAmount,
-            Amount stakingNetAmount
-        ) = FeeLib.calculateFee(
-            _getStakingFee(instanceReader, poolNftId), 
-            stakingAmount);
 
+        // create the empty bundle
         bundleNftId = _bundleService.create(
             instance,
             poolNftId,
             bundleOwner,
             fee,
-            stakingNetAmount,
+            AmountLib.zero(), 
             lifetime,
             filter);
 
-        // pool book keeping
-        _componentService.increasePoolBalance(
-            instance.getInstanceStore(), 
-            poolNftId, 
-            stakingAmount, 
-            stakingFeeAmount);
-
-        // pool bookkeeping and collect tokens from bundle owner
-        _collectStakingAmount(
-            instanceReader, 
-            poolNftId, 
-            bundleOwner, 
-            stakingAmount);
-
         emit LogPoolServiceBundleCreated(instance.getNftId(), poolNftId, bundleNftId);
     }
 
@@ -198,8 +133,8 @@ contract PoolService is
         view
         returns (Fee memory stakingFee)
     {
-        NftId productNftId = instanceReader.getPoolInfo(poolNftId).productNftId;
-        return instanceReader.getPoolInfo(productNftId).stakingFee;
+        NftId productNftId = instanceReader.getComponentInfo(poolNftId).productNftId;
+        return instanceReader.getProductInfo(productNftId).stakingFee;
     }
 
     function closeBundle(NftId bundleNftId)
@@ -208,20 +143,147 @@ contract PoolService is
     {
         (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 stake(NftId bundleNftId, Amount amount) 
+        external 
+        virtual
+        // TODO: restricted() (once #462 is done)
+        returns(Amount netAmount) 
+    {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+        if (bundleInfo.poolNftId != poolNftId) {
+            revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+
+        {
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + amount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, amount);
+            }
+        }
+
+        // calculate fees
+        Amount feeAmount;
+        (
+            feeAmount,
+            netAmount
+        ) = FeeLib.calculateFee(
+            _getStakingFee(instanceReader, poolNftId), 
+            amount);
+
+        // do all the bookkeeping
+        _componentService.increasePoolBalance(
+            instance.getInstanceStore(), 
+            poolNftId, 
+            netAmount, 
+            feeAmount);
+
+        _bundleService.stake(instance, bundleNftId, netAmount);
+
+        // collect tokens from bundle owner
+        address bundleOwner = getRegistry().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);
+    }
+
+    /// @inheritdoc IPoolService
+    function unstake(NftId bundleNftId, Amount amount) 
+        external 
+        virtual
+        // TODO: restricted() (once #462 is done)
+        returns(Amount netAmount) 
+    {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        InstanceStore instanceStore = instance.getInstanceStore();
+        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+        
+        if (bundleInfo.poolNftId != poolNftId) {
+            revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+
+        // call bundle service for bookkeeping and additional checks
+        Amount unstakedAmount = _bundleService.unstake(instance, bundleNftId, amount);
+
+        // Important: from now on work only with unstakedAmount as it is the only reliable amount.
+        // if amount was max, this was set to the available amount
+
+        // TODO: handle performance fees (issue #477)
+
+        // update pool bookkeeping - performance fees stay in the pool, but as fees 
+        _componentService.decreasePoolBalance(
+            instanceStore, 
+            poolNftId, 
+            unstakedAmount, 
+            AmountLib.zero());
+
+        IComponents.ComponentInfo memory poolComponentInfo = instanceReader.getComponentInfo(poolNftId);
+        address poolWallet = poolComponentInfo.wallet;
+        // transfer amount to bundle owner
+        address owner = getRegistry().ownerOf(bundleNftId);
+        emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount);
+        poolComponentInfo.tokenHandler.distributeTokens(
+            poolWallet, 
+            owner, 
+            unstakedAmount);
+        return unstakedAmount;
+    }
+
+
+    function fundPoolWallet(NftId poolNftId, Amount amount)
+        external
+        virtual
+        restricted()
+    {
+        // TODO check that poolNftId is externally managed
+        // TODO implement
     }
 
 
+    function defundPoolWallet(NftId poolNftId, Amount amount)
+        external
+        virtual
+        restricted()
+    {
+        // TODO check that poolNftId is externally managed
+        // TODO implement
+    }
+
     function processSale(
         NftId bundleNftId, 
-        IPolicy.Premium memory premium 
+        IPolicy.PremiumInfo memory premium 
     ) 
         external
         virtual
@@ -233,9 +295,9 @@ contract PoolService is
         IRegistry.ObjectInfo memory instanceObjectInfo = registry.getObjectInfo(poolObjectInfo.parentNftId);
         IInstance instance = IInstance(instanceObjectInfo.objectAddress);
 
-        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(
@@ -421,7 +483,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,
@@ -434,15 +495,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()) {
-            tokenHandler.transfer(
-                bundleOwner,
-                poolWallet,
-                amount);
-        }
+        componentInfo.tokenHandler.collectTokens(
+            bundleOwner,
+            poolWallet,
+            amount);
     }
 
     function _getDomain() internal pure override returns(ObjectType) {

package/contracts/pool/PoolServiceManager.sol

@@ -1,12 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {PoolService} from "./PoolService.sol";
-import {Registry} from "../registry/Registry.sol";
-import {RegistryService} from "../registry/RegistryService.sol";
-import {REGISTRY} from "../type/ObjectType.sol";
 
 contract PoolServiceManager is ProxyManager {
 
@@ -15,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);