Merge pull request #389 from The-Poolz/issue-386

use `IFundsManager` instead of `Collateral` type

contracts/AdvancedProviders/CollateralProvider/CollateralProvider.sol

@@ -1,13 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "../../interfaces/IFundsManager.sol";
 import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
 import "./CollateralState.sol";
 import "../../util/CalcUtils.sol";
 import "@ironblocks/firewall-consumer/contracts/FirewallConsumer.sol";
 
-contract CollateralProvider is IFundsManager, ERC721Holder, CollateralState, FirewallConsumer {
+contract CollateralProvider is ERC721Holder, CollateralState, FirewallConsumer {
     using CalcUtils for uint256;
 
     ///@dev withdraw tokens
@@ -36,10 +35,7 @@ contract CollateralProvider is IFundsManager, ERC721Holder, CollateralState, Fir
     /// @param params[0] = token amount
     /// @param params[params.length - 2] = main coin amount
     /// @param params[params.length - 1] = FinishTime
-    function _registerPool(uint256 poolId, uint256[] calldata params)
-        internal
-        firewallProtectedSig(0x8b60dedb)
-    {
+    function _registerPool(uint256 poolId, uint256[] calldata params) internal firewallProtectedSig(0x8b60dedb) {
         uint256 tokenAmount = params[0];
         uint256 mainCoinAmount = params[params.length - 2];
         uint256 finishTime = params[params.length - 1];

contracts/AdvancedProviders/CollateralProvider/CollateralState.sol

@@ -5,8 +5,9 @@ import "../../SimpleProviders/LockProvider/LockDealState.sol";
 import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import "../../SimpleProviders/Provider/ProviderModifiers.sol";
 import "../../interfaces/IInnerWithdraw.sol";
+import "../../interfaces/FundsManager.sol";
 
-abstract contract CollateralState is LockDealState, IInnerWithdraw, IERC165, ProviderModifiers {
+abstract contract CollateralState is IInnerWithdraw, FundsManager, IERC165, ProviderModifiers {
     mapping(uint256 => uint256) public poolIdToRateToWei;
 
     function getParams(uint256 poolId) public view override returns (uint256[] memory params) {
@@ -26,7 +27,7 @@ abstract contract CollateralState is LockDealState, IInnerWithdraw, IERC165, Pro
         }
     }
 
-    function currentParamsTargetLength() public pure override returns (uint256) {
+    function currentParamsTargetLength() public pure override(IProvider, ProviderState) returns (uint256) {
         return 3;
     }
 
@@ -42,7 +43,7 @@ abstract contract CollateralState is LockDealState, IInnerWithdraw, IERC165, Pro
         if (lockDealNFT.poolIdToProvider(poolId) == this) {
             (uint256 mainCoinCollectorId, , uint256 mainCoinHolderId) = getInnerIds(poolId);
             withdrawalAmount = lockDealNFT.getWithdrawableAmount(mainCoinCollectorId);
-            if (poolIdToTime[poolId] <= block.timestamp) {
+            if (isPoolFinished(poolId)) {
                 withdrawalAmount += lockDealNFT.getWithdrawableAmount(mainCoinHolderId);
             }
         }
@@ -54,14 +55,14 @@ abstract contract CollateralState is LockDealState, IInnerWithdraw, IERC165, Pro
         return interfaceId == type(IERC165).interfaceId || interfaceId == type(IInnerWithdraw).interfaceId;
     }
 
-    function getSubProvidersPoolIds(uint256 poolId) public view virtual override returns (uint256[] memory poolIds) {
+    function getSubProvidersPoolIds(uint256 poolId) public view virtual override(IProvider, ProviderState) returns (uint256[] memory poolIds) {
         if (lockDealNFT.poolIdToProvider(poolId) == this) {
             poolIds = new uint256[](3);
             (poolIds[0], poolIds[1], poolIds[2]) = getInnerIds(poolId);
         }
     }
 
-    function isPoolFinished(uint256 poolId) public view returns (bool) {
-        return poolIdToTime[poolId] < block.timestamp;
+    function isPoolFinished(uint256 poolId) public view override returns (bool) {
+        return poolIdToTime[poolId] <= block.timestamp;
     }
 }

contracts/AdvancedProviders/RefundProvider/RefundProvider.sol

@@ -3,14 +3,15 @@ pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 import "../../ERC165/Refundble.sol";
+import "../../interfaces/ISimpleProvider.sol";
 import "./RefundState.sol";
 import "@ironblocks/firewall-consumer/contracts/FirewallConsumer.sol";
 
 contract RefundProvider is RefundState, IERC721Receiver, FirewallConsumer {
     constructor(ILockDealNFT nftContract, address provider) {
         require(address(nftContract) != address(0x0) && provider != address(0x0), "RefundProvider: invalid address");
         lockDealNFT = nftContract;
-        collateralProvider = CollateralProvider(provider);
+        collateralProvider = FundsManager(provider);
         name = "RefundProvider";
     }
 
@@ -24,14 +25,13 @@ contract RefundProvider is RefundState, IERC721Receiver, FirewallConsumer {
         require(msg.sender == address(lockDealNFT), "RefundProvider: invalid nft contract");
         if (provider == user) {
             uint256 collateralPoolId = poolIdToCollateralId[poolId];
-            require(
-                collateralProvider.poolIdToTime(collateralPoolId) > block.timestamp,
-                "RefundProvider: Refund period has expired"
-            );
+            require(!collateralProvider.isPoolFinished(collateralPoolId), "RefundProvider: Refund period has expired");
             ISimpleProvider dealProvider = collateralProvider.provider();
+            // user pool id can be TimedProvider, LockProvider or DealProvider
             uint256 userDataPoolId = poolId + 1;
             // User receives a refund and the tokens go into the collateral pool
             uint256 amount = dealProvider.getParams(userDataPoolId)[0];
+            // using directly the deal provider for withdraw
             (uint256 withdrawnAmount, ) = dealProvider.withdraw(userDataPoolId, amount);
             collateralProvider.handleRefund(collateralPoolId, user, withdrawnAmount);
         }
@@ -136,7 +136,7 @@ contract RefundProvider is RefundState, IERC721Receiver, FirewallConsumer {
         uint256 userDataPoolId = poolId + 1;
         IProvider provider = lockDealNFT.poolIdToProvider(userDataPoolId);
         amountToBeWithdrawed = provider.getWithdrawableAmount(userDataPoolId);
-        if (collateralProvider.poolIdToTime(poolIdToCollateralId[poolId]) >= block.timestamp) {
+        if (!collateralProvider.isPoolFinished(poolIdToCollateralId[poolId])) {
             collateralProvider.handleWithdraw(poolIdToCollateralId[poolId], amountToBeWithdrawed);
         }
         isFinal = provider.getParams(userDataPoolId)[0] == amountToBeWithdrawed;

contracts/AdvancedProviders/RefundProvider/RefundState.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "../CollateralProvider/CollateralProvider.sol";
+import "../../interfaces/FundsManager.sol";
+import "../../SimpleProviders/Provider/ProviderModifiers.sol";
+import "../../util/CalcUtils.sol";
 import "../../interfaces/IInnerWithdraw.sol";
 
 abstract contract RefundState is ProviderModifiers, IInnerWithdraw, IERC165 {
     using CalcUtils for uint256;
 
-    CollateralProvider public collateralProvider;
+    FundsManager public collateralProvider;
     mapping(uint256 => uint256) public poolIdToCollateralId;
 
     ///@return params  params [0] = tokenLeftAmount; - user(poolId + 1) data
@@ -18,7 +20,7 @@ abstract contract RefundState is ProviderModifiers, IInnerWithdraw, IERC165 {
             params = new uint256[](2);
             uint256 tokenAmount = dataParams[0];
             uint256 collateralPoolId = poolIdToCollateralId[poolId];
-            uint256 rateToWei = collateralProvider.poolIdToRateToWei(collateralPoolId);
+            uint256 rateToWei = collateralProvider.getParams(collateralPoolId)[2];
             params[0] = tokenAmount;
             params[1] = tokenAmount.calcAmount(rateToWei);
         }

contracts/interfaces/FundsManager.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./IProvider.sol";
+import "../SimpleProviders/LockProvider/LockDealState.sol";
+
+abstract contract FundsManager is LockDealState, IProvider {
+    function handleWithdraw(uint256 poolId, uint256 tokenAmount) external virtual {}
+    function handleRefund(uint256 poolId, address user, uint256 tokenAmount) external virtual {}
+    function isPoolFinished(uint256 poolId) external view virtual returns (bool) {}
+}

contracts/mock/MockProvider.sol

@@ -2,11 +2,11 @@
 pragma solidity ^0.8.0;
 
 import "../SimpleProviders/TimedDealProvider/TimedDealProvider.sol";
-import "../interfaces/IFundsManager.sol";
+import "../interfaces/FundsManager.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 /// @dev MockProvider is a contract for testing purposes.
-contract MockProvider is IFundsManager {
+contract MockProvider {
     IProvider public _provider;
     ILockDealNFT public lockDealNFT;
 
@@ -53,11 +53,11 @@ contract MockProvider is IFundsManager {
     }
 
     function handleWithdraw(uint256 poolId, uint256 tokenAmount) external {
-        IFundsManager(address(_provider)).handleWithdraw(poolId, tokenAmount);
+        FundsManager(address(_provider)).handleWithdraw(poolId, tokenAmount);
     }
 
     function handleRefund(uint256 poolId, address user, uint256 tokenAmount) external {
-        IFundsManager(address(_provider)).handleRefund(poolId, user, tokenAmount);
+        FundsManager(address(_provider)).handleRefund(poolId, user, tokenAmount);
     }
 
     function registerNewRefundPool(address owner, IProvider provider) external returns (uint256 poolId) {

contracts/mock/MockTransfer.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.0;
 
 import "../SimpleProviders/DealProvider/DealProvider.sol";
-import "../interfaces/IFundsManager.sol";
 import "../interfaces/IBeforeTransfer.sol";
 
 contract MockTransfer is IBeforeTransfer, DealProvider {