@harvest-finance/harvest-strategy-polygon 0.0.1-security → 1.0.0

package/contracts/base/FeeRewardForwarder.sol

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "./inheritance/Governable.sol";
+import "./interface/IRewardPool.sol";
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/math/Math.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+import "@openzeppelin/contracts/GSN/Context.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
+
+contract FeeRewardForwarder is Governable {
+  using SafeERC20 for IERC20;
+  using SafeMath for uint256;
+
+  address constant public weth = address(0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619);
+  address constant public wmatic = address(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);
+  address constant public quick = address(0x831753DD7087CaC61aB5644b308642cc1c33Dc13);
+
+  address constant public ifarm = address(0xab0b2ddB9C7e440fAc8E140A89c0dbCBf2d7Bbff);
+  address constant public sushi = address(0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a);
+  address constant public usdc = address(0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174);
+  address constant public aave = address(0xD6DF932A45C0f255f85145f286eA0b292B21C90B);
+
+
+  mapping (address => mapping (address => address[])) public routes;
+  mapping (address => mapping (address => address[])) public routers;
+
+  address constant public quickswapRouter = address(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff);
+  address constant public sushiswapRouter = address(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
+
+  // the targeted reward token to convert everything to
+  address public targetToken = weth;
+  address public profitSharingPool;
+
+  event TokenPoolSet(address token, address pool);
+
+  constructor(address _storage) public Governable(_storage) {
+    profitSharingPool = governance();
+
+    routes[quick][weth] = [quick, weth];
+    routers[quick][weth] = [quickswapRouter];
+
+    routes[sushi][weth] = [sushi, weth];
+    routers[sushi][weth] = [sushiswapRouter];
+
+    routes[wmatic][weth] = [wmatic, weth];
+    routers[wmatic][weth] = [quickswapRouter];
+  }
+
+  /*
+  *   Set the pool that will receive the reward token
+  *   based on the address of the reward Token
+  */
+  function setEOA(address _eoa) public onlyGovernance {
+    profitSharingPool = _eoa;
+    targetToken = weth;
+    emit TokenPoolSet(targetToken, _eoa);
+  }
+
+  /**
+  * Sets the path for swapping tokens to the to address
+  * The to address is not validated to match the targetToken,
+  * so that we could first update the paths, and then,
+  * set the new target
+  */
+  function setConversionPath(address[] memory _route, address[] memory _routers)
+    public
+    onlyGovernance
+  {
+    require(
+      _routers.length == 1 || _routers.length == _route.length-1,
+      "Provide either 1 router in total, or 1 router per intermediate pair"
+    );
+    address from = _route[0];
+    address to = _route[_route.length-1];
+    routes[from][to] = _route;
+    routers[from][to] = _routers;
+  }
+
+  // Transfers the funds from the msg.sender to the pool
+  // under normal circumstances, msg.sender is the strategy
+  function poolNotifyFixedTarget(address _token, uint256 _amount) external {
+    uint256 remainingAmount = _amount;
+
+    if (_token == weth) {
+      // this is already the right token
+      IERC20(_token).safeTransferFrom(msg.sender, profitSharingPool, _amount);
+    } else {
+
+      // we need to convert _token to WETH
+      if (routes[_token][targetToken].length > 1) {
+        IERC20(_token).safeTransferFrom(msg.sender, address(this), remainingAmount);
+        uint256 balanceToSwap = IERC20(_token).balanceOf(address(this));
+        if (routers[_token][targetToken].length == 1) {
+          liquidate(_token, targetToken, balanceToSwap);
+        } else if (routers[_token][targetToken].length > 1) {
+          liquidateMultiRouter(_token, targetToken, balanceToSwap);
+        } else {
+          revert("FeeRewardForwarder: liquidation routers not set");
+        }
+
+        // now we can send this token forward
+        uint256 convertedRewardAmount = IERC20(targetToken).balanceOf(address(this));
+
+        IERC20(targetToken).safeTransfer(profitSharingPool, convertedRewardAmount);
+      } else {
+        // else the route does not exist for this token
+        // do not take any fees and revert.
+        // It's better to set the liquidation path then perform it again,
+        // rather then leaving the funds in controller
+        revert("FeeRewardForwarder: liquidation path doesn't exist");
+      }
+    }
+  }
+
+  function liquidate(address _from, address _to, uint256 balanceToSwap) internal {
+    if(balanceToSwap > 0){
+      address router = routers[_from][_to][0];
+      IERC20(_from).safeApprove(router, 0);
+      IERC20(_from).safeApprove(router, balanceToSwap);
+
+      IUniswapV2Router02(router).swapExactTokensForTokens(
+        balanceToSwap,
+        0,
+        routes[_from][_to],
+        address(this),
+        block.timestamp
+      );
+    }
+  }
+
+  function liquidateMultiRouter(address _from, address _to, uint256 balanceToSwap) internal {
+    if(balanceToSwap > 0){
+      address[] memory _routers = routers[_from][_to];
+      address[] memory _route = routes[_from][_to];
+      for (uint256 i; i < _routers.length; i++ ) {
+        address router = _routers[i];
+        address[] memory route = new address[](2);
+        route[0] = _route[i];
+        route[1] = _route[i+1];
+        uint256 amount = IERC20(route[0]).balanceOf(address(this));
+        IERC20(route[0]).safeApprove(router, 0);
+        IERC20(route[0]).safeApprove(router, amount);
+
+        IUniswapV2Router02(router).swapExactTokensForTokens(
+          amount,
+          0,
+          route,
+          address(this),
+          block.timestamp
+        );
+      }
+    }
+  }
+}

package/contracts/base/PotPool.sol

@@ -0,0 +1,360 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "./inheritance/Controllable.sol";
+import "./interface/IController.sol";
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/math/Math.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+import "@openzeppelin/contracts/GSN/Context.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+abstract contract IRewardDistributionRecipient is Ownable {
+
+    mapping (address => bool) public rewardDistribution;
+
+    constructor(address[] memory _rewardDistributions) public {
+        // multisig on Matic
+        rewardDistribution[0x39cC360806b385C96969ce9ff26c23476017F652] = true;
+        // NotifyHelper
+        rewardDistribution[0xF71042C88458ff1702c3870f62F4c764712Cc9F0] = true;
+
+        for(uint256 i = 0; i < _rewardDistributions.length; i++) {
+          rewardDistribution[_rewardDistributions[i]] = true;
+        }
+    }
+
+    function notifyTargetRewardAmount(address rewardToken, uint256 reward) external virtual;
+    function notifyRewardAmount(uint256 reward) external virtual;
+
+    modifier onlyRewardDistribution() {
+        require(rewardDistribution[_msgSender()], "Caller is not reward distribution");
+        _;
+    }
+
+    function setRewardDistribution(address[] calldata _newRewardDistribution, bool _flag)
+        external
+        onlyOwner
+    {
+        for(uint256 i = 0; i < _newRewardDistribution.length; i++){
+          rewardDistribution[_newRewardDistribution[i]] = _flag;
+        }
+    }
+}
+
+contract PotPool is IRewardDistributionRecipient, Controllable, ERC20 {
+
+    using Address for address;
+    using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+
+    address public lpToken;
+    uint256 public duration; // making it not a constant is less gas efficient, but portable
+
+    mapping(address => uint256) public stakedBalanceOf;
+
+    mapping (address => bool) smartContractStakers;
+    address[] public rewardTokens;
+    mapping(address => uint256) public periodFinishForToken;
+    mapping(address => uint256) public rewardRateForToken;
+    mapping(address => uint256) public lastUpdateTimeForToken;
+    mapping(address => uint256) public rewardPerTokenStoredForToken;
+    mapping(address => mapping(address => uint256)) public userRewardPerTokenPaidForToken;
+    mapping(address => mapping(address => uint256)) public rewardsForToken;
+
+    event RewardAdded(address rewardToken, uint256 reward);
+    event Staked(address indexed user, uint256 amount);
+    event Withdrawn(address indexed user, uint256 amount);
+    event RewardPaid(address indexed user, address rewardToken, uint256 reward);
+    event RewardDenied(address indexed user, address rewardToken, uint256 reward);
+    event SmartContractRecorded(address indexed smartContractAddress, address indexed smartContractInitiator);
+
+    modifier onlyGovernanceOrRewardDistribution() {
+      require(msg.sender == governance() || rewardDistribution[msg.sender], "Not governance nor reward distribution");
+      _;
+    }
+
+    modifier updateRewards(address account) {
+      for(uint256 i = 0; i < rewardTokens.length; i++ ){
+        address rt = rewardTokens[i];
+        rewardPerTokenStoredForToken[rt] = rewardPerToken(rt);
+        lastUpdateTimeForToken[rt] = lastTimeRewardApplicable(rt);
+        if (account != address(0)) {
+            rewardsForToken[rt][account] = earned(rt, account);
+            userRewardPerTokenPaidForToken[rt][account] = rewardPerTokenStoredForToken[rt];
+        }
+      }
+      _;
+    }
+
+    modifier updateReward(address account, address rt){
+      rewardPerTokenStoredForToken[rt] = rewardPerToken(rt);
+      lastUpdateTimeForToken[rt] = lastTimeRewardApplicable(rt);
+      if (account != address(0)) {
+          rewardsForToken[rt][account] = earned(rt, account);
+          userRewardPerTokenPaidForToken[rt][account] = rewardPerTokenStoredForToken[rt];
+      }
+      _;
+    }
+
+    /** View functions to respect old interface */
+    function rewardToken() public view returns(address) {
+      return rewardTokens[0];
+    }
+
+    function rewardPerToken() public view returns(uint256) {
+      return rewardPerToken(rewardTokens[0]);
+    }
+
+    function periodFinish() public view returns(uint256) {
+      return periodFinishForToken[rewardTokens[0]];
+    }
+
+    function rewardRate() public view returns(uint256) {
+      return rewardRateForToken[rewardTokens[0]];
+    }
+
+    function lastUpdateTime() public view returns(uint256) {
+      return lastUpdateTimeForToken[rewardTokens[0]];
+    }
+
+    function rewardPerTokenStored() public view returns(uint256) {
+      return rewardPerTokenStoredForToken[rewardTokens[0]];
+    }
+
+    function userRewardPerTokenPaid(address user) public view returns(uint256) {
+      return userRewardPerTokenPaidForToken[rewardTokens[0]][user];
+    }
+
+    function rewards(address user) public view returns(uint256) {
+      return rewardsForToken[rewardTokens[0]][user];
+    }
+
+    // [Hardwork] setting the reward, lpToken, duration, and rewardDistribution for each pool
+    constructor(
+        address[] memory _rewardTokens,
+        address _lpToken,
+        uint256 _duration,
+        address[] memory _rewardDistribution,
+        address _storage,
+        string memory _name,
+        string memory _symbol,
+        uint8 _decimals
+      ) public
+      ERC20(_name, _symbol)
+      IRewardDistributionRecipient(_rewardDistribution)
+      Controllable(_storage) // only used for referencing the grey list
+    {
+        require(_decimals == ERC20(_lpToken).decimals(), "decimals has to be aligned with the lpToken");
+        require(_rewardTokens.length != 0, "should initialize with at least 1 rewardToken");
+        rewardTokens = _rewardTokens;
+        lpToken = _lpToken;
+        duration = _duration;
+    }
+
+    function lastTimeRewardApplicable(uint256 i) public view returns (uint256) {
+        return lastTimeRewardApplicable(rewardTokens[i]);
+    }
+
+    function lastTimeRewardApplicable(address rt) public view returns (uint256) {
+        return Math.min(block.timestamp, periodFinishForToken[rt]);
+    }
+
+    function lastTimeRewardApplicable() public view returns (uint256) {
+        return lastTimeRewardApplicable(rewardTokens[0]);
+    }
+
+    function rewardPerToken(uint256 i) public view returns (uint256) {
+        return rewardPerToken(rewardTokens[i]);
+    }
+
+    function rewardPerToken(address rt) public view returns (uint256) {
+        if (totalSupply() == 0) {
+            return rewardPerTokenStoredForToken[rt];
+        }
+        return
+            rewardPerTokenStoredForToken[rt].add(
+                lastTimeRewardApplicable(rt)
+                    .sub(lastUpdateTimeForToken[rt])
+                    .mul(rewardRateForToken[rt])
+                    .mul(1e18)
+                    .div(totalSupply())
+            );
+    }
+
+    function earned(uint256 i, address account) public view returns (uint256) {
+        return earned(rewardTokens[i], account);
+    }
+
+    function earned(address account) public view returns (uint256) {
+        return earned(rewardTokens[0], account);
+    }
+
+    function earned(address rt, address account) public view returns (uint256) {
+        return
+            stakedBalanceOf[account]
+                .mul(rewardPerToken(rt).sub(userRewardPerTokenPaidForToken[rt][account]))
+                .div(1e18)
+                .add(rewardsForToken[rt][account]);
+    }
+
+    function stake(uint256 amount) public updateRewards(msg.sender) {
+        require(amount > 0, "Cannot stake 0");
+        recordSmartContract();
+        super._mint(msg.sender, amount); // ERC20 is used as a staking receipt
+        stakedBalanceOf[msg.sender] = stakedBalanceOf[msg.sender].add(amount);
+        IERC20(lpToken).safeTransferFrom(msg.sender, address(this), amount);
+        emit Staked(msg.sender, amount);
+    }
+
+    function withdraw(uint256 amount) public updateRewards(msg.sender) {
+        require(amount > 0, "Cannot withdraw 0");
+        super._burn(msg.sender, amount);
+        stakedBalanceOf[msg.sender] = stakedBalanceOf[msg.sender].sub(amount);
+        IERC20(lpToken).safeTransfer(msg.sender, amount);
+        emit Withdrawn(msg.sender, amount);
+    }
+
+    function exit() external {
+        withdraw(Math.min(stakedBalanceOf[msg.sender], balanceOf(msg.sender)));
+        getAllRewards();
+    }
+
+    /// A push mechanism for accounts that have not claimed their rewards for a long time.
+    /// The implementation is semantically analogous to getReward(), but uses a push pattern
+    /// instead of pull pattern.
+    function pushAllRewards(address recipient) public updateRewards(recipient) onlyGovernance {
+      bool rewardPayout = (!smartContractStakers[recipient] || !IController(controller()).greyList(recipient));
+      for(uint256 i = 0 ; i < rewardTokens.length; i++ ){
+        uint256 reward = earned(rewardTokens[i], recipient);
+        if (reward > 0) {
+            rewardsForToken[rewardTokens[i]][recipient] = 0;
+            // If it is a normal user and not smart contract,
+            // then the requirement will pass
+            // If it is a smart contract, then
+            // make sure that it is not on our greyList.
+            if (rewardPayout) {
+                IERC20(rewardTokens[i]).safeTransfer(recipient, reward);
+                emit RewardPaid(recipient, rewardTokens[i], reward);
+            } else {
+                emit RewardDenied(recipient, rewardTokens[i], reward);
+            }
+        }
+      }
+    }
+
+    function getAllRewards() public updateRewards(msg.sender) {
+      recordSmartContract();
+      bool rewardPayout = (!smartContractStakers[msg.sender] || !IController(controller()).greyList(msg.sender));
+      for(uint256 i = 0 ; i < rewardTokens.length; i++ ){
+        _getRewardAction(rewardTokens[i], rewardPayout);
+      }
+    }
+
+    function getReward(address rt) public updateReward(msg.sender, rt) {
+      recordSmartContract();
+      _getRewardAction(
+        rt,
+        // don't payout if it is a grey listed smart contract
+        (!smartContractStakers[msg.sender] || !IController(controller()).greyList(msg.sender))
+      );
+    }
+
+    function getReward() public {
+      getReward(rewardTokens[0]);
+    }
+
+    function _getRewardAction(address rt, bool rewardPayout) internal {
+      uint256 reward = earned(rt, msg.sender);
+      if (reward > 0 && IERC20(rt).balanceOf(address(this)) >= reward ) {
+          rewardsForToken[rt][msg.sender] = 0;
+          // If it is a normal user and not smart contract,
+          // then the requirement will pass
+          // If it is a smart contract, then
+          // make sure that it is not on our greyList.
+          if (rewardPayout) {
+              IERC20(rt).safeTransfer(msg.sender, reward);
+              emit RewardPaid(msg.sender, rt, reward);
+          } else {
+              emit RewardDenied(msg.sender, rt, reward);
+          }
+      }
+    }
+
+    function addRewardToken(address rt) public onlyGovernanceOrRewardDistribution {
+      require(getRewardTokenIndex(rt) == uint256(-1), "Reward token already exists");
+      rewardTokens.push(rt);
+    }
+
+    function removeRewardToken(address rt) public onlyGovernanceOrRewardDistribution {
+      uint256 i = getRewardTokenIndex(rt);
+      require(i != uint256(-1), "Reward token does not exists");
+      require(periodFinishForToken[rewardTokens[i]] < block.timestamp, "Can only remove when the reward period has passed");
+      require(rewardTokens.length > 1, "Cannot remove the last reward token");
+      uint256 lastIndex = rewardTokens.length - 1;
+
+      // swap
+      rewardTokens[i] = rewardTokens[lastIndex];
+
+      // delete last element
+      rewardTokens.pop();
+    }
+
+    // If the return value is MAX_UINT256, it means that
+    // the specified reward token is not in the list
+    function getRewardTokenIndex(address rt) public view returns(uint256) {
+      for(uint i = 0 ; i < rewardTokens.length ; i++){
+        if(rewardTokens[i] == rt)
+          return i;
+      }
+      return uint256(-1);
+    }
+
+    function notifyTargetRewardAmount(address _rewardToken, uint256 reward)
+        public override
+        onlyRewardDistribution
+        updateRewards(address(0))
+    {
+        // overflow fix according to https://sips.synthetix.io/sips/sip-77
+        require(reward < uint(-1) / 1e18, "the notified reward cannot invoke multiplication overflow");
+
+        uint256 i = getRewardTokenIndex(_rewardToken);
+        require(i != uint256(-1), "rewardTokenIndex not found");
+
+        if (block.timestamp >= periodFinishForToken[_rewardToken]) {
+            rewardRateForToken[_rewardToken] = reward.div(duration);
+        } else {
+            uint256 remaining = periodFinishForToken[_rewardToken].sub(block.timestamp);
+            uint256 leftover = remaining.mul(rewardRateForToken[_rewardToken]);
+            rewardRateForToken[_rewardToken] = reward.add(leftover).div(duration);
+        }
+        lastUpdateTimeForToken[_rewardToken] = block.timestamp;
+        periodFinishForToken[_rewardToken] = block.timestamp.add(duration);
+        emit RewardAdded(_rewardToken, reward);
+    }
+
+    function notifyRewardAmount(uint256 reward)
+        external override
+        onlyRewardDistribution
+        updateRewards(address(0))
+    {
+      notifyTargetRewardAmount(rewardTokens[0], reward);
+    }
+
+    function rewardTokensLength() public view returns(uint256){
+      return rewardTokens.length;
+    }
+
+    // Harvest Smart Contract recording
+    function recordSmartContract() internal {
+      if( tx.origin != msg.sender ) {
+        smartContractStakers[msg.sender] = true;
+        emit SmartContractRecorded(msg.sender, tx.origin);
+      }
+    }
+
+}

package/contracts/base/ProfitSharingReceiver.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import "./inheritance/Governable.sol";
+import "./interface/IProfitSharingReceiver.sol";
+
+
+/**
+ * A simple contract for receiving tokens for profit sharing. This contract is designed to pool rewards that will be
+ * sent by governance to Ethereum mainnet for FARM buybacks
+ */
+contract ProfitSharingReceiver is Governable {
+    using SafeERC20 for IERC20;
+
+    event WithdrawToken(address indexed token, address indexed receiver, uint amount);
+
+    constructor(
+        address _store
+    )
+    public
+    Governable(_store) {}
+
+    function withdrawTokens(address[] calldata _tokens) external onlyGovernance {
+        address _governance = governance();
+        for (uint i = 0; i < _tokens.length; ++i) {
+            uint amount = IERC20(_tokens[i]).balanceOf(address(this));
+            if (amount > 0) {
+                IERC20(_tokens[i]).safeTransfer(_governance, amount);
+                emit WithdrawToken(_tokens[i], _governance, amount);
+            }
+        }
+    }
+
+}

package/contracts/base/RewardForwarderV2.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import "./inheritance/Governable.sol";
+import "./interface/IControllerV2.sol";
+import "./interface/IRewardForwarder.sol";
+import "./interface/IProfitSharingReceiver.sol";
+import "./interface/IStrategy.sol";
+import "./interface/IUniversalLiquidator.sol";
+import "./inheritance/Controllable.sol";
+
+/**
+ * @dev This contract receives rewards from strategies and is responsible for routing the reward's liquidation into
+ *      specific buyback tokens and profit tokens for the DAO.
+ */
+contract RewardForwarderV2 is Controllable {
+    using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+
+    address public constant iFARM = address(0xab0b2ddB9C7e440fAc8E140A89c0dbCBf2d7Bbff);
+
+    constructor(
+        address _storage
+    ) public Controllable(_storage) {}
+
+    function notifyFee(
+        address _token,
+        uint256 _profitSharingFee,
+        uint256 _strategistFee,
+        uint256 _platformFee
+    ) external {
+        _notifyFee(
+            _token,
+            _profitSharingFee,
+            _strategistFee,
+            _platformFee
+        );
+    }
+
+    function _notifyFee(
+        address _token,
+        uint256 _profitSharingFee,
+        uint256 _strategistFee,
+        uint256 _platformFee
+    ) internal {
+        address _controller = controller();
+        address liquidator = IControllerV2(_controller).universalLiquidator();
+
+        uint totalTransferAmount = _profitSharingFee.add(_strategistFee).add(_platformFee);
+        require(totalTransferAmount > 0, "totalTransferAmount should not be 0");
+        IERC20(_token).safeTransferFrom(msg.sender, address(this), totalTransferAmount);
+
+        address _targetToken = IControllerV2(_controller).targetToken();
+
+        if (_token != _targetToken) {
+            IERC20(_token).safeApprove(liquidator, 0);
+            IERC20(_token).safeApprove(liquidator, _platformFee);
+
+            uint amountOutMin = 1;
+
+            if (_platformFee > 0) {
+                IUniversalLiquidator(liquidator).swap(
+                    _token,
+                    _targetToken,
+                    _platformFee,
+                    amountOutMin,
+                    IControllerV2(_controller).protocolFeeReceiver()
+                );
+            }
+        } else {
+            IERC20(_targetToken).safeTransfer(IControllerV2(_controller).protocolFeeReceiver(), _platformFee);
+        }
+
+        if (_token != iFARM) {
+            IERC20(_token).safeApprove(liquidator, 0);
+            IERC20(_token).safeApprove(liquidator, _profitSharingFee.add(_strategistFee));
+
+            uint amountOutMin = 1;
+
+            if (_profitSharingFee > 0) {
+                IUniversalLiquidator(liquidator).swap(
+                    _token,
+                    iFARM,
+                    _profitSharingFee,
+                    amountOutMin,
+                    IControllerV2(_controller).profitSharingReceiver()
+                );
+            }
+            if (_strategistFee > 0) {
+                IUniversalLiquidator(liquidator).swap(
+                    _token,
+                    iFARM,
+                    _strategistFee,
+                    amountOutMin,
+                    IStrategy(msg.sender).strategist()
+                );
+            }
+        } else {
+            if (_strategistFee > 0) {
+                IERC20(iFARM).safeTransfer(IStrategy(msg.sender).strategist(), _strategistFee);
+            }
+            IERC20(iFARM).safeTransfer(IControllerV2(_controller).profitSharingReceiver(), _profitSharingFee);
+        }
+    }
+}