@etherisc/gif-next 0.0.2-96b5b72-170 → 0.0.2-9723682-800

package/contracts/pool/Pool.sol

@@ -2,18 +2,22 @@
 pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "../type/Amount.sol";
-import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
+import {BUNDLE, COMPONENT, POLICY, POOL} from "../type/ObjectType.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {IBundleService} from "./IBundleService.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {BUNDLE, POOL} from "../type/ObjectType.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {Fee} from "../type/Fee.sol";
+import {NftId} from "../type/NftId.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
-import {UFixed, UFixedLib} from "../type/UFixed.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {UFixed} from "../type/UFixed.sol";
 
 abstract contract Pool is
     InstanceLinkedComponent, 
@@ -23,6 +27,8 @@ abstract contract Pool is
     bytes32 public constant POOL_STORAGE_LOCATION_V1 = 0x25e3e51823fbfffb988e0a2744bb93722d9f3e906c07cc0a9e77884c46c58300;
 
     struct PoolStorage {
+        IComponents.PoolInfo _poolInfo;
+        IComponentService _componentService;
         IPoolService _poolService;
         IBundleService _bundleService;
     }
@@ -36,261 +42,286 @@ abstract contract Pool is
     }
 
 
-    modifier onlyPoolService() {
-        if(msg.sender != address(_getPoolStorage()._poolService)) {
-            revert ErrorPoolNotPoolService(msg.sender);
-        }
-        _;
+    // 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 initializePool(
-        address registry,
-        NftId instanceNftId,
-        string memory name,
-        address token,
-        bool isInterceptingNftTransfers,
-        address initialOwner,
-        bytes memory registryData // writeonly data that will saved in the object info record of the registry
+    /// @dev see {IPoolComponent.verifyApplication}
+    function verifyApplication(
+        NftId applicationNftId, 
+        NftId bundleNftId, 
+        Amount collateralizationAmount
     )
         public
         virtual
-        onlyInitializing()
+        restricted()
+        onlyNftOfType(applicationNftId, POLICY())
     {
-        initializeComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, registryData);
-
-        PoolStorage storage $ = _getPoolStorage();
-        $._poolService = IPoolService(_getServiceAddress(POOL())); 
-        $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
+        InstanceReader reader = _getInstanceReader();
+        if(!applicationMatchesBundle(
+            applicationNftId,
+            reader.getPolicyInfo(applicationNftId).applicationData, 
+            bundleNftId, 
+            reader.getBundleInfo(bundleNftId).filter,
+            collateralizationAmount)
+        )
+        {
+            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
+        }
 
-        registerInterface(type(IPoolComponent).interfaceId);
+        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
     }
 
 
-    function stake(
-        NftId bundleNftId, 
+    /// @dev see {IPoolComponent.processConfirmedClaim}
+    function processConfirmedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
         Amount amount
     )
         public
         virtual
         restricted()
-        onlyBundleOwner(bundleNftId)
+        onlyNftOfType(policyNftId, POLICY())
     {
-        // TODO add implementation
+        // default implementation is empty
     }
 
 
-    function unstake(
+    /// @dev see {IPoolComponent.applicationMatchesBundle}
+    /// Default implementation always returns true.
+    /// Override this function to implement any custom application verification.
+    /// Calling super.applicationMatchesBundle will ensure validation of application and bundle nft ids.
+    function applicationMatchesBundle(
+        NftId applicationNftId, 
+        bytes memory applicationData,
         NftId bundleNftId, 
-        Amount amount
+        bytes memory bundleFilter,
+        Amount collateralizationAmount
     )
         public
         virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
+        view
+        onlyNftOfType(applicationNftId, POLICY())
+        onlyNftOfType(bundleNftId, BUNDLE())
+        returns (bool isMatching)
     {
-        // TODO add implementation
+        return true;
     }
 
 
-    function extend(
-        NftId bundleNftId, 
-        Seconds lifetimeExtension
+    function getInitialPoolInfo()
+        public 
+        virtual 
+        view 
+        returns (IComponents.PoolInfo memory poolInfo)
+    {
+        return _getPoolStorage()._poolInfo;
+    }
+
+    // Internals
+
+    function _initializePool(
+        address registry,
+        NftId productNftId,
+        string memory name,
+        IComponents.PoolInfo memory poolInfo,
+        IAuthorization authorization,
+        address initialOwner,
+        bytes memory componentData // component specifidc data 
     )
-        public
+        internal
         virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
+        onlyInitializing()
     {
-        // TODO add implementation
+        _initializeInstanceLinkedComponent(
+            registry, 
+            productNftId,  
+            name, 
+            POOL(), 
+            authorization, 
+            poolInfo.isInterceptingBundleTransfers, 
+            initialOwner, 
+            componentData);
+
+        PoolStorage storage $ = _getPoolStorage();
+
+        $._poolInfo = poolInfo;
+        $._poolService = IPoolService(_getServiceAddress(POOL())); 
+        $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        _registerInterface(type(IPoolComponent).interfaceId);
     }
 
 
-    function lockBundle(NftId bundleNftId)
-        public
+    /// @dev Update pool fees to the specified values.
+    /// Pool fee: are deducted from the premium amount and goes to the pool owner.
+    /// Staking fee: are deducted from the staked tokens by a bundle owner and goes to the pool owner.
+    /// Performance fee: when a bundle is closed a bundle specific profit is calculated.
+    /// The performance fee is deducted from this profit and goes to the pool owner.
+    function _setPoolFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    )
+        internal
         virtual
-        //restricted() // TODO consider adding this back
-        onlyBundleOwner(bundleNftId)
     {
-        _getPoolStorage()._bundleService.lock(bundleNftId);
+        _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
     }
 
 
-    function unlockBundle(NftId bundleNftId)
-        public
+    /// @dev Sets the maximum balance amound held by this pool.
+    /// Function may only be called by pool owner.
+    function _setMaxBalanceAmount(Amount maxBalanceAmount)
+        internal
         virtual
-        //restricted()
-        onlyBundleOwner(bundleNftId)
     {
-        _getPoolStorage()._bundleService.unlock(bundleNftId);
+        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
     }
 
 
-    function close(NftId bundleNftId)
-        public
+    /// @dev Fund the pool wallet with the specified amount.
+    /// Function is only available for externally managed pools.
+    function _fundPoolWallet(Amount amount)
+        internal
         virtual
-        //restricted()
-        onlyBundleOwner(bundleNftId)
     {
-        _getPoolStorage()._poolService.closeBundle(bundleNftId);
+        _getPoolStorage()._poolService.fundPoolWallet(amount);
     }
 
 
-    function setBundleFee(
-        NftId bundleNftId, 
-        Fee memory fee
-    )
-        public
+    /// @dev Withdraw the specified amount from the pool wallet.
+    /// Function is only available for externally managed pools.
+    function _defundPoolWallet(Amount amount)
+        internal
         virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
     {
-        _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
+        _getPoolStorage()._poolService.defundPoolWallet(amount);
     }
 
 
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
-        public
-        virtual
-        restricted()
-        onlyOwner()
+    /// @dev Creates a new empty bundle using the provided parameter values.
+    function _createBundle(
+        address bundleOwner,
+        Fee memory fee,
+        Seconds lifetime, 
+        bytes memory filter
+    )
+        internal
+        returns(NftId bundleNftId)
     {
-        _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
+        bundleNftId = _getPoolStorage()._bundleService.create(
+            bundleOwner,
+            fee,
+            lifetime,
+            filter);
+
+        // TODO add logging
     }
 
 
-    function setBundleOwnerRole(RoleId bundleOwnerRole)
-        public
+    /// @dev Sets the fee for the specified bundle.
+    /// The fee is added on top of the poolFee and deducted from the premium amounts
+    /// Via these fees individual bundler owner may earn income per policy in the context of peer to peer pools.
+    function _setBundleFee(
+        NftId bundleNftId, 
+        Fee memory fee
+    )
+        internal
         virtual
-        restricted()
-        onlyOwner()
     {
-        _getPoolStorage()._poolService.setBundleOwnerRole(bundleOwnerRole);
+        _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
     }
 
 
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
+    /// @dev increases the staked tokens by the specified amount
+    /// bundle MUST be in active or locked state
+    function _stake(
+        NftId bundleNftId, 
+        Amount amount
     )
-        public
+        internal
         virtual
-        restricted()
-        onlyOwner()
+        returns(Amount) 
     {
-        _getPoolStorage()._poolService.setFees(poolFee, stakingFee, performanceFee);
+        return _getPoolStorage()._poolService.stake(bundleNftId, amount);
     }
 
 
-    /// @dev see {IPool.verifyApplication}
-    function verifyApplication(
-        NftId applicationNftId, 
-        bytes memory applicationData,
+    /// @dev decreases the staked tokens by the specified amount
+    /// bundle MUST be in active, locked or closed state
+    function _unstake(
         NftId bundleNftId, 
-        bytes memory bundleFilter,
-        Amount collateralizationAmount
+        Amount amount
     )
-        public
+        internal
         virtual
-        restricted()
+        returns(Amount netAmount) 
     {
-        if(!applicationMatchesBundle(
-            applicationNftId,
-            applicationData, 
-            bundleNftId, 
-            bundleFilter,
-            collateralizationAmount)
-        )
-        {
-            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
-        }
-
-        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
+        return _getPoolStorage()._poolService.unstake(bundleNftId, amount);
     }
 
 
-    /// @dev see {IPoolComponent.applicationMatchesBundle}
-    /// Override this function to implement any custom application verification 
-    /// Default implementation always returns true
-    function applicationMatchesBundle(
-        NftId applicationNftId, 
-        bytes memory applicationData,
+    /// @dev extends the bundle lifetime of the bundle by the specified time
+    /// bundle MUST be in active or locked state
+    function _extend(
         NftId bundleNftId, 
-        bytes memory bundleFilter,
-        Amount collateralizationAmount
+        Seconds lifetimeExtension
     )
-        public
-        view
-        virtual override
-        returns (bool isMatching)
+        internal
+        virtual
+        returns (Timestamp extendedExpiredAt) 
     {
-        return true;
+        return _getPoolStorage()._bundleService.extend(bundleNftId, lifetimeExtension);
     }
 
 
-    function getPoolInfo() external view returns (IComponents.PoolInfo memory poolInfo) {
-        poolInfo = abi.decode(getComponentInfo().data, (IComponents.PoolInfo));
+    /// @dev Locks the specified bundle.
+    /// A bundle to be locked MUST be in active state.
+    /// Locked bundles may not be used to collateralize any new policy.
+    function _setBundleLocked(NftId bundleNftId, bool locked)
+        internal
+        virtual
+    {
+        _getPoolStorage()._bundleService.setLocked(bundleNftId, locked);
     }
 
-    // Internals
 
-    function _createBundle(
-        address bundleOwner,
-        Fee memory fee,
-        Amount amount,
-        Seconds lifetime, 
-        bytes memory filter
-    )
+    /// @dev Close the specified bundle.
+    /// A bundle to be closed MUST be in active or locked state.
+    /// To close a bundle all all linked policies MUST be in closed state as well.
+    /// Closing a bundle finalizes the bundle bookkeeping including overall profit calculation.
+    /// Once a bundle is closed this action cannot be reversed.
+    function _closeBundle(NftId bundleNftId)
         internal
-        returns(NftId bundleNftId)
+        virtual
     {
-        bundleNftId = _getPoolStorage()._poolService.createBundle(
-            bundleOwner,
-            fee,
-            amount,
-            lifetime,
-            filter);
-
-        // TODO add logging
+        _getPoolStorage()._poolService.closeBundle(bundleNftId);
     }
 
-    // TODO remove function once this is no longer used to produce contract locations on the fly ...
-    function getContractLocation(bytes memory name) external pure returns (bytes32 hash) {
-        return keccak256(abi.encode(uint256(keccak256(name)) - 1)) & ~bytes32(uint256(0xff));
+
+    /// @dev Withdraws the specified amount of fees from the bundle.
+    function _withdrawBundleFees(NftId bundleNftId, Amount amount) 
+        internal
+        returns (Amount withdrawnAmount) 
+    {
+        return _getPoolStorage()._poolService.withdrawBundleFees(bundleNftId, amount);
     }
 
-    /// @dev defines initial pool specification
-    /// overwrite this function according to your use case
-    function _getInitialInfo()
+
+    function _processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    )
         internal
-        view 
-        virtual override
-        returns (IComponents.ComponentInfo memory info)
     {
-        return IComponents.ComponentInfo(
-            getName(),
-            getToken(),
-            TokenHandler(address(0)), // will be created by GIF service during registration
-            address(this), // contract is its own wallet
-            AmountLib.zero(), // balance amount
-            AmountLib.zero(), // fee amount
-            abi.encode(
-                IComponents.PoolInfo(
-                    NftIdLib.zero(), // will be set when GIF registers the related product
-                    PUBLIC_ROLE(), // bundleOwnerRole
-                    AmountLib.max(), // maxCapitalAmount,
-                    AmountLib.zero(), // initial balance amount
-                    AmountLib.zero(), // initial fee amount
-                    isNftInterceptor(), // isInterceptingBundleTransfers
-                    false, // isExternallyManaged,
-                    false, // isVerifyingApplications,
-                    UFixedLib.toUFixed(1), // collateralizationLevel,
-                    UFixedLib.toUFixed(1), // retentionLevel,
-                    FeeLib.zeroFee(), // initialPoolFee,
-                    FeeLib.zeroFee(), // initialStakingFee,
-                    FeeLib.zeroFee() // initialPerformanceFee,
-                )));
+        _getPoolStorage()._poolService.processFundedClaim(
+            policyNftId, claimId, availableAmount);
     }