@etherisc/gif-next 0.0.2-f080b71-868 → 0.0.2-f083368-470

package/contracts/{instance/service → pool}/IPoolService.sol

@@ -1,37 +1,37 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-
-import {Amount} from "../../types/Amount.sol";
-import {Fee} from "../../types/Fee.sol";
-import {NftId} from "../../types/NftId.sol";
-import {IBundle} from "../module/IBundle.sol";
-import {IInstance} from "../../instance/IInstance.sol";
-import {IPolicy} from "../module/IPolicy.sol";
-import {IService} from "../../shared/IService.sol";
-import {RoleId} from "../../types/RoleId.sol";
-import {Seconds} from "../../types/Seconds.sol";
-import {StateId} from "../../types/StateId.sol";
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {Fee} from "../type/Fee.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {IBundle} from "../instance/module/IBundle.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
+import {IService} from "../shared/IService.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {StateId} from "../type/StateId.sol";
+import {UFixed} from "../type/UFixed.sol";
 
 interface IPoolService is IService {
 
-    event LogPoolServiceMaxCapitalAmountUpdated(NftId poolNftId, uint256 previousMaxCapitalAmount, uint256 currentMaxCapitalAmount);
+    event LogPoolServiceMaxCapitalAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
     event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
 
     event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
     event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
 
     error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
-    error ErrorPoolServiceBundlePoolMismatch(NftId bundlePoolNftId, NftId productPoolNftId);
-
-    /// @dev registers a new pool with the registry service
-    function register(address poolAddress) external returns(NftId);
+    error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
 
     /// @dev defines the required role for bundle owners for the calling pool
     /// default implementation returns PUBLIC ROLE
     function setBundleOwnerRole(RoleId bundleOwnerRole) external;
 
     /// @dev sets the max capital amount for the calling pool
-    function setMaxCapitalAmount(uint256 maxCapitalAmount) external;
+    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
 
     /// @dev set pool sepecific fees
     function setFees(
@@ -48,22 +48,41 @@ interface IPoolService is IService {
     /// may only be called by the policy service for unlocked pool components
     function lockCollateral(
         IInstance instance, 
+        address token,
         NftId productNftId,
         NftId applicationNftId,
-        IPolicy.PolicyInfo memory applicationInfo,
-        uint256 premiumAmount
-    ) external;
+        NftId bundleNftId,
+        Amount sumInsuredAmount // premium amount after product and distribution fees
+    )
+        external
+        returns (
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        );
 
 
     /// @dev releases the remaining collateral linked to the specified policy
     /// may only be called by the policy service for unlocked pool components
     function releaseCollateral(
         IInstance instance, 
+        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo
     ) external;
 
 
+    /// @dev reduces the locked collateral in the bundle associated with the specified policy
+    /// every payout of a policy reduces the collateral by the payout amount
+    /// may only be called by the claim service for unlocked pool components
+    function reduceCollateral(
+        IInstance instance, 
+        address token,
+        NftId policyNftId, 
+        IPolicy.PolicyInfo memory policyInfo,
+        Amount payoutAmount
+    ) external;
+
+
     /// @dev create a new bundle for the provided parameters
     /// staking fees will be deducted by the pool service from the staking amount
     /// may only be called by registered and unlocked pool components
@@ -86,6 +105,9 @@ interface IPoolService is IService {
     function closeBundle(NftId bundleNftId) external;
 
 
+    /// @dev processes the sale of a bundle and track the pool fee and bundle fee amounts
+    function processSale(NftId bundleNftId, IPolicy.Premium memory premium) external;
+
     /// @dev increase stakes for bundle
     /// staking fees will be deducted by the pool service from the staking amount
     /// may only be called by registered and unlocked pool components
@@ -96,4 +118,33 @@ interface IPoolService is IService {
     /// performance fees will be deducted by the pool service from the staking amount
     /// may only be called by registered and unlocked pool components
     // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+
+
+    /// @dev calulate required collateral for the provided parameters
+    function calculateRequiredCollateral(
+        InstanceReader instanceReader,
+        NftId productNftId, 
+        Amount sumInsuredAmount
+    )
+        external
+        view 
+        returns(
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        );
+
+
+    /// @dev calulate required collateral for the provided parameters
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        UFixed retentionLevel, 
+        Amount sumInsuredAmount
+    )
+        external
+        pure 
+        returns(
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        );
+
 }

package/contracts/pool/Pool.sol

@@ -0,0 +1,328 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.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 {IComponentService} from "../shared/IComponentService.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+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 {TokenHandler} from "../shared/TokenHandler.sol";
+import {UFixed, UFixedLib} from "../type/UFixed.sol";
+
+abstract contract Pool is
+    InstanceLinkedComponent, 
+    IPoolComponent 
+{
+    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.Pool")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant POOL_STORAGE_LOCATION_V1 = 0x25e3e51823fbfffb988e0a2744bb93722d9f3e906c07cc0a9e77884c46c58300;
+
+    struct PoolStorage {
+        IComponentService _componentService;
+        IPoolService _poolService;
+        IBundleService _bundleService;
+    }
+
+
+    modifier onlyBundleOwner(NftId bundleNftId) {
+        if(msg.sender != getRegistry().ownerOf(bundleNftId)) {
+            revert ErrorPoolNotBundleOwner(bundleNftId, msg.sender);
+        }
+        _;
+    }
+
+
+    /// @dev see {IPoolComponent.verifyApplication}
+    function verifyApplication(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        Amount collateralizationAmount
+    )
+        public
+        virtual
+        restricted()
+    {
+        if(!applicationMatchesBundle(
+            applicationNftId,
+            applicationData, 
+            bundleNftId, 
+            bundleFilter,
+            collateralizationAmount)
+        )
+        {
+            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
+        }
+
+        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
+    }
+
+
+    /// @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,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        Amount collateralizationAmount
+    )
+        public
+        virtual
+        view
+        returns (bool isMatching)
+    {
+        return true;
+    }
+
+
+    function register()
+        external
+        virtual
+        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);
+    }
+
+
+    function getInitialPoolInfo()
+        public 
+        virtual 
+        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,
+        );
+    }
+
+    // Internals
+
+    function _initializePool(
+        address registry,
+        NftId instanceNftId,
+        string memory name,
+        address token,
+        IAuthorization authorization,
+        bool isInterceptingNftTransfers,
+        address initialOwner,
+        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bytes memory componentData // component specifidc data 
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _initializeInstanceLinkedComponent(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            POOL(), 
+            authorization, 
+            isInterceptingNftTransfers, 
+            initialOwner, 
+            registryData, 
+            componentData);
+
+        PoolStorage storage $ = _getPoolStorage();
+        $._poolService = IPoolService(_getServiceAddress(POOL())); 
+        $._bundleService = IBundleService(_getServiceAddress(BUNDLE()));
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        registerInterface(type(IPoolComponent).interfaceId);
+    }
+
+    /// @dev increases the staked tokens by the specified amount
+    /// bundle MUST be in active or locked state
+    function _stake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        internal
+        virtual
+    {
+        // TODO add implementation
+    }
+
+
+    /// @dev decreases the staked tokens by the specified amount
+    /// bundle MUST be in active, locked or closed state
+    function _unstake(
+        NftId bundleNftId, 
+        Amount amount
+    )
+        internal
+        virtual
+    {
+        // TODO add implementation
+    }
+
+
+    /// @dev extends the bundle lifetime of the bundle by the specified time
+    /// bundle MUST be in active or locked state
+    function _extend(
+        NftId bundleNftId, 
+        Seconds lifetimeExtension
+    )
+        internal
+        virtual
+    {
+        // TODO add implementation
+    }
+
+
+    /// @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 _lockBundle(NftId bundleNftId)
+        internal
+        virtual
+    {
+        _getPoolStorage()._bundleService.lock(bundleNftId);
+    }
+
+
+    /// @dev Unlocks the specified bundle.
+    /// A bundle to be unlocked MUST be in locked state.
+    function _unlockBundle(NftId bundleNftId)
+        internal
+        virtual
+    {
+        _getPoolStorage()._bundleService.unlock(bundleNftId);
+    }
+
+
+    /// @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 _close(NftId bundleNftId)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.closeBundle(bundleNftId);
+    }
+
+
+    /// @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
+    {
+        _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
+    }
+
+
+    /// @dev Sets the maximum overall capital amound held by this pool.
+    /// Function may only be called by pool owner.
+    function _setMaxCapitalAmount(Amount maxCapitalAmount)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
+    }
+
+    /// @dev Sets the required role to create/own bundles.
+    /// May only be called once after setting up a pool.
+    /// May only be called by pool owner.
+    function _setBundleOwnerRole(RoleId bundleOwnerRole)
+        internal
+        virtual
+    {
+        _getPoolStorage()._poolService.setBundleOwnerRole(bundleOwnerRole);
+    }
+
+
+    /// @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
+    {
+        _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
+    }
+
+    /// @dev Creates a new bundle using the provided parameter values.
+    function _createBundle(
+        address bundleOwner,
+        Fee memory fee,
+        Amount amount,
+        Seconds lifetime, 
+        bytes memory filter
+    )
+        internal
+        returns(NftId bundleNftId)
+    {
+        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 {
+            $.slot := POOL_STORAGE_LOCATION_V1
+        }
+    }
+}