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

package/contracts/base/upgradability/BaseUpgradeableStrategyStorage.sol

@@ -0,0 +1,176 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+
+contract BaseUpgradeableStrategyStorage {
+
+  bytes32 internal constant _UNDERLYING_SLOT = 0xa1709211eeccf8f4ad5b6700d52a1a9525b5f5ae1e9e5f9e5a0c2fc23c86e530;
+  bytes32 internal constant _VAULT_SLOT = 0xefd7c7d9ef1040fc87e7ad11fe15f86e1d11e1df03c6d7c87f7e1f4041f08d41;
+
+  bytes32 internal constant _REWARD_TOKEN_SLOT = 0xdae0aafd977983cb1e78d8f638900ff361dc3c48c43118ca1dd77d1af3f47bbf;
+  bytes32 internal constant _REWARD_POOL_SLOT = 0x3d9bb16e77837e25cada0cf894835418b38e8e18fbec6cfd192eb344bebfa6b8;
+  bytes32 internal constant _SELL_FLOOR_SLOT = 0xc403216a7704d160f6a3b5c3b149a1226a6080f0a5dd27b27d9ba9c022fa0afc;
+  bytes32 internal constant _SELL_SLOT = 0x656de32df98753b07482576beb0d00a6b949ebf84c066c765f54f26725221bb6;
+  bytes32 internal constant _PAUSED_INVESTING_SLOT = 0xa07a20a2d463a602c2b891eb35f244624d9068572811f63d0e094072fb54591a;
+
+  bytes32 internal constant _PROFIT_SHARING_NUMERATOR_SLOT = 0xe3ee74fb7893020b457d8071ed1ef76ace2bf4903abd7b24d3ce312e9c72c029;
+  bytes32 internal constant _PROFIT_SHARING_DENOMINATOR_SLOT = 0x0286fd414602b432a8c80a0125e9a25de9bba96da9d5068c832ff73f09208a3b;
+
+  bytes32 internal constant _NEXT_IMPLEMENTATION_SLOT = 0x29f7fcd4fe2517c1963807a1ec27b0e45e67c60a874d5eeac7a0b1ab1bb84447;
+  bytes32 internal constant _NEXT_IMPLEMENTATION_TIMESTAMP_SLOT = 0x414c5263b05428f1be1bfa98e25407cc78dd031d0d3cd2a2e3d63b488804f22e;
+  bytes32 internal constant _NEXT_IMPLEMENTATION_DELAY_SLOT = 0x82b330ca72bcd6db11a26f10ce47ebcfe574a9c646bccbc6f1cd4478eae16b31;
+
+  constructor() public {
+    assert(_UNDERLYING_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.underlying")) - 1));
+    assert(_VAULT_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.vault")) - 1));
+    assert(_REWARD_TOKEN_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.rewardToken")) - 1));
+    assert(_REWARD_POOL_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.rewardPool")) - 1));
+    assert(_SELL_FLOOR_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.sellFloor")) - 1));
+    assert(_SELL_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.sell")) - 1));
+    assert(_PAUSED_INVESTING_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.pausedInvesting")) - 1));
+
+    assert(_PROFIT_SHARING_NUMERATOR_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.profitSharingNumerator")) - 1));
+    assert(_PROFIT_SHARING_DENOMINATOR_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.profitSharingDenominator")) - 1));
+
+    assert(_NEXT_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.nextImplementation")) - 1));
+    assert(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.nextImplementationTimestamp")) - 1));
+    assert(_NEXT_IMPLEMENTATION_DELAY_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.nextImplementationDelay")) - 1));
+  }
+
+  function _setUnderlying(address _address) internal {
+    setAddress(_UNDERLYING_SLOT, _address);
+  }
+
+  function underlying() public virtual view returns (address) {
+    return getAddress(_UNDERLYING_SLOT);
+  }
+
+  function _setRewardPool(address _address) internal {
+    setAddress(_REWARD_POOL_SLOT, _address);
+  }
+
+  function rewardPool() public view returns (address) {
+    return getAddress(_REWARD_POOL_SLOT);
+  }
+
+  function _setRewardToken(address _address) internal {
+    setAddress(_REWARD_TOKEN_SLOT, _address);
+  }
+
+  function rewardToken() public view returns (address) {
+    return getAddress(_REWARD_TOKEN_SLOT);
+  }
+
+  function _setVault(address _address) internal {
+    setAddress(_VAULT_SLOT, _address);
+  }
+
+  function vault() public virtual view returns (address) {
+    return getAddress(_VAULT_SLOT);
+  }
+
+  // a flag for disabling selling for simplified emergency exit
+  function _setSell(bool _value) internal {
+    setBoolean(_SELL_SLOT, _value);
+  }
+
+  function sell() public view returns (bool) {
+    return getBoolean(_SELL_SLOT);
+  }
+
+  function _setPausedInvesting(bool _value) internal {
+    setBoolean(_PAUSED_INVESTING_SLOT, _value);
+  }
+
+  function pausedInvesting() public view returns (bool) {
+    return getBoolean(_PAUSED_INVESTING_SLOT);
+  }
+
+  function _setSellFloor(uint256 _value) internal {
+    setUint256(_SELL_FLOOR_SLOT, _value);
+  }
+
+  function sellFloor() public view returns (uint256) {
+    return getUint256(_SELL_FLOOR_SLOT);
+  }
+
+  function _setProfitSharingNumerator(uint256 _value) internal {
+    setUint256(_PROFIT_SHARING_NUMERATOR_SLOT, _value);
+  }
+
+  function profitSharingNumerator() public view returns (uint256) {
+    return getUint256(_PROFIT_SHARING_NUMERATOR_SLOT);
+  }
+
+  function _setProfitSharingDenominator(uint256 _value) internal {
+    setUint256(_PROFIT_SHARING_DENOMINATOR_SLOT, _value);
+  }
+
+  function profitSharingDenominator() public view returns (uint256) {
+    return getUint256(_PROFIT_SHARING_DENOMINATOR_SLOT);
+  }
+
+  // upgradeability
+
+  function _setNextImplementation(address _address) internal {
+    setAddress(_NEXT_IMPLEMENTATION_SLOT, _address);
+  }
+
+  function nextImplementation() public view returns (address) {
+    return getAddress(_NEXT_IMPLEMENTATION_SLOT);
+  }
+
+  function _setNextImplementationTimestamp(uint256 _value) internal {
+    setUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT, _value);
+  }
+
+  function nextImplementationTimestamp() public view returns (uint256) {
+    return getUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT);
+  }
+
+  function _setNextImplementationDelay(uint256 _value) internal {
+    setUint256(_NEXT_IMPLEMENTATION_DELAY_SLOT, _value);
+  }
+
+  function nextImplementationDelay() public view returns (uint256) {
+    return getUint256(_NEXT_IMPLEMENTATION_DELAY_SLOT);
+  }
+
+  function setBoolean(bytes32 slot, bool _value) internal {
+    setUint256(slot, _value ? 1 : 0);
+  }
+
+  function getBoolean(bytes32 slot) internal view returns (bool) {
+    return (getUint256(slot) == 1);
+  }
+
+  function setAddress(bytes32 slot, address _address) internal {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, _address)
+    }
+  }
+
+  function setUint256(bytes32 slot, uint256 _value) internal {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, _value)
+    }
+  }
+
+  function getAddress(bytes32 slot) internal view returns (address str) {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+
+  function getUint256(bytes32 slot) internal view returns (uint256 str) {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+}

package/contracts/base/upgradability/BaseUpgradeableStrategyStorageV2.sol

@@ -0,0 +1,290 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "../interface/IControllerV2.sol";
+import "../inheritance/ControllableInit.sol";
+
+contract BaseUpgradeableStrategyStorageV2 is ControllableInit {
+
+  event ProfitsNotCollected(
+      address indexed rewardToken,
+      bool sell,
+      bool floor
+  );
+  event ProfitLogInReward(
+      address indexed rewardToken,
+      uint256 profitAmount,
+      uint256 feeAmount,
+      uint256 timestamp
+  );
+  event ProfitAndBuybackLog(
+      address indexed rewardToken,
+      uint256 profitAmount,
+      uint256 feeAmount,
+      uint256 timestamp
+  );
+  event PlatformFeeLogInReward(
+      address indexed treasury,
+      address indexed rewardToken,
+      uint256 profitAmount,
+      uint256 feeAmount,
+      uint256 timestamp
+  );
+  event StrategistFeeLogInReward(
+      address indexed strategist,
+      address indexed rewardToken,
+      uint256 profitAmount,
+      uint256 feeAmount,
+      uint256 timestamp
+  );
+
+  bytes32 internal constant _UNDERLYING_SLOT = 0xa1709211eeccf8f4ad5b6700d52a1a9525b5f5ae1e9e5f9e5a0c2fc23c86e530;
+  bytes32 internal constant _VAULT_SLOT = 0xefd7c7d9ef1040fc87e7ad11fe15f86e1d11e1df03c6d7c87f7e1f4041f08d41;
+
+  bytes32 internal constant _REWARD_TOKEN_SLOT = 0xdae0aafd977983cb1e78d8f638900ff361dc3c48c43118ca1dd77d1af3f47bbf;
+  bytes32 internal constant _REWARD_TOKENS_SLOT = 0x45418d9b5c2787ae64acbffccad43f2b487c1a16e24385aa9d2b059f9d1d163c;
+  bytes32 internal constant _REWARD_POOL_SLOT = 0x3d9bb16e77837e25cada0cf894835418b38e8e18fbec6cfd192eb344bebfa6b8;
+  bytes32 internal constant _SELL_FLOOR_SLOT = 0xc403216a7704d160f6a3b5c3b149a1226a6080f0a5dd27b27d9ba9c022fa0afc;
+  bytes32 internal constant _SELL_SLOT = 0x656de32df98753b07482576beb0d00a6b949ebf84c066c765f54f26725221bb6;
+  bytes32 internal constant _PAUSED_INVESTING_SLOT = 0xa07a20a2d463a602c2b891eb35f244624d9068572811f63d0e094072fb54591a;
+
+  bytes32 internal constant _PROFIT_SHARING_NUMERATOR_SLOT = 0xe3ee74fb7893020b457d8071ed1ef76ace2bf4903abd7b24d3ce312e9c72c029;
+  bytes32 internal constant _PROFIT_SHARING_DENOMINATOR_SLOT = 0x0286fd414602b432a8c80a0125e9a25de9bba96da9d5068c832ff73f09208a3b;
+
+  bytes32 internal constant _NEXT_IMPLEMENTATION_SLOT = 0x29f7fcd4fe2517c1963807a1ec27b0e45e67c60a874d5eeac7a0b1ab1bb84447;
+  bytes32 internal constant _NEXT_IMPLEMENTATION_TIMESTAMP_SLOT = 0x414c5263b05428f1be1bfa98e25407cc78dd031d0d3cd2a2e3d63b488804f22e;
+  bytes32 internal constant _NEXT_IMPLEMENTATION_DELAY_SLOT = 0x82b330ca72bcd6db11a26f10ce47ebcfe574a9c646bccbc6f1cd4478eae16b31;
+
+  bytes32 internal constant _STRATEGIST_SLOT = 0x6a7b588c950d46e2de3db2f157e5e0e4f29054c8d60f17bf0c30352e223a458d;
+
+  constructor() public {
+    assert(_UNDERLYING_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.underlying")) - 1));
+    assert(_VAULT_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.vault")) - 1));
+    assert(_REWARD_TOKEN_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.rewardToken")) - 1));
+    assert(_REWARD_TOKENS_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.rewardTokens")) - 1));
+    assert(_REWARD_POOL_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.rewardPool")) - 1));
+    assert(_SELL_FLOOR_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.sellFloor")) - 1));
+    assert(_SELL_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.sell")) - 1));
+    assert(_PAUSED_INVESTING_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.pausedInvesting")) - 1));
+
+    assert(_PROFIT_SHARING_NUMERATOR_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.profitSharingNumerator")) - 1));
+    assert(_PROFIT_SHARING_DENOMINATOR_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.profitSharingDenominator")) - 1));
+
+    assert(_NEXT_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.nextImplementation")) - 1));
+    assert(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.nextImplementationTimestamp")) - 1));
+    assert(_NEXT_IMPLEMENTATION_DELAY_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.nextImplementationDelay")) - 1));
+
+    assert(_STRATEGIST_SLOT == bytes32(uint256(keccak256("eip1967.strategyStorage.strategist")) - 1));
+  }
+
+  function _setUnderlying(address _address) internal {
+    setAddress(_UNDERLYING_SLOT, _address);
+  }
+
+  function underlying() public virtual view returns (address) {
+    return getAddress(_UNDERLYING_SLOT);
+  }
+
+  function _setRewardPool(address _address) internal {
+    setAddress(_REWARD_POOL_SLOT, _address);
+  }
+
+  function rewardPool() public view returns (address) {
+    return getAddress(_REWARD_POOL_SLOT);
+  }
+
+  function _setRewardToken(address _address) internal {
+    setAddress(_REWARD_TOKEN_SLOT, _address);
+  }
+
+  function rewardToken() public view returns (address) {
+    return getAddress(_REWARD_TOKEN_SLOT);
+  }
+
+  function _setRewardTokens(address[] memory _rewardTokens) internal {
+    setAddressArray(_REWARD_TOKENS_SLOT, _rewardTokens);
+  }
+
+  function isRewardToken(address _token) public view returns (bool) {
+    return _isAddressInList(_token, rewardTokens());
+  }
+
+  function rewardTokens() public view returns (address[] memory) {
+    return getAddressArray(_REWARD_TOKENS_SLOT);
+  }
+
+  function _isAddressInList(address _searchValue, address[] memory _list) internal pure returns (bool) {
+    for (uint i = 0; i < _list.length; i++) {
+      if (_list[i] == _searchValue) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function _setStrategist(address _strategist) internal {
+    setAddress(_STRATEGIST_SLOT, _strategist);
+  }
+
+  function strategist() public view returns (address) {
+    return getAddress(_STRATEGIST_SLOT);
+  }
+
+  function _setVault(address _address) internal {
+    setAddress(_VAULT_SLOT, _address);
+  }
+
+  function vault() public virtual view returns (address) {
+    return getAddress(_VAULT_SLOT);
+  }
+
+  // a flag for disabling selling for simplified emergency exit
+  function _setSell(bool _value) internal {
+    setBoolean(_SELL_SLOT, _value);
+  }
+
+  function sell() public view returns (bool) {
+    return getBoolean(_SELL_SLOT);
+  }
+
+  function _setPausedInvesting(bool _value) internal {
+    setBoolean(_PAUSED_INVESTING_SLOT, _value);
+  }
+
+  function pausedInvesting() public view returns (bool) {
+    return getBoolean(_PAUSED_INVESTING_SLOT);
+  }
+
+  function _setSellFloor(uint256 _value) internal {
+    setUint256(_SELL_FLOOR_SLOT, _value);
+  }
+
+  function sellFloor() public view returns (uint256) {
+    return getUint256(_SELL_FLOOR_SLOT);
+  }
+
+  function profitSharingNumerator() public view returns (uint256) {
+    return IControllerV2(controller()).profitSharingNumerator();
+  }
+
+  function platformFeeNumerator() public view returns (uint256) {
+    return IControllerV2(controller()).platformFeeNumerator();
+  }
+
+  function strategistFeeNumerator() public view returns (uint256) {
+    return IControllerV2(controller()).strategistFeeNumerator();
+  }
+
+  function feeDenominator() public view returns (uint256) {
+    return IControllerV2(controller()).feeDenominator();
+  }
+
+  function universalLiquidator() public view returns (address) {
+    return IControllerV2(controller()).universalLiquidator();
+  }
+
+  // upgradeability
+
+  function _setNextImplementation(address _address) internal {
+    setAddress(_NEXT_IMPLEMENTATION_SLOT, _address);
+  }
+
+  function nextImplementation() public view returns (address) {
+    return getAddress(_NEXT_IMPLEMENTATION_SLOT);
+  }
+
+  function _setNextImplementationTimestamp(uint256 _value) internal {
+    setUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT, _value);
+  }
+
+  function nextImplementationTimestamp() public view returns (uint256) {
+    return getUint256(_NEXT_IMPLEMENTATION_TIMESTAMP_SLOT);
+  }
+
+    function nextImplementationDelay() public view returns (uint256) {
+        return IControllerV2(controller()).nextImplementationDelay();
+    }
+
+  function setBoolean(bytes32 slot, bool _value) internal {
+    setUint256(slot, _value ? 1 : 0);
+  }
+
+  function getBoolean(bytes32 slot) internal view returns (bool) {
+    return (getUint256(slot) == 1);
+  }
+
+  function setAddress(bytes32 slot, address _address) internal {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, _address)
+    }
+  }
+
+  function setUint256(bytes32 slot, uint256 _value) internal {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      sstore(slot, _value)
+    }
+  }
+
+  function getAddress(bytes32 slot) internal view returns (address str) {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+
+  function getUint256(bytes32 slot) internal view returns (uint256 str) {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      str := sload(slot)
+    }
+  }
+
+      function setUint256Array(bytes32 slot, uint256[] memory _values) internal {
+        // solhint-disable-next-line no-inline-assembly
+        setUint256(slot, _values.length);
+        for (uint i = 0; i < _values.length; i++) {
+            setUint256(bytes32(uint(slot) + 1 + i), _values[i]);
+        }
+    }
+
+    function setAddressArray(bytes32 slot, address[] memory _values) internal {
+        // solhint-disable-next-line no-inline-assembly
+        setUint256(slot, _values.length);
+        for (uint i = 0; i < _values.length; i++) {
+            setAddress(bytes32(uint(slot) + 1 + i), _values[i]);
+        }
+    }
+
+
+    function getUint256Array(bytes32 slot) internal view returns (uint[] memory values) {
+        // solhint-disable-next-line no-inline-assembly
+        values = new uint[](getUint256(slot));
+        for (uint i = 0; i < values.length; i++) {
+            values[i] = getUint256(bytes32(uint(slot) + 1 + i));
+        }
+    }
+
+    function getAddressArray(bytes32 slot) internal view returns (address[] memory values) {
+        // solhint-disable-next-line no-inline-assembly
+        values = new address[](getUint256(slot));
+        for (uint i = 0; i < values.length; i++) {
+            values[i] = getAddress(bytes32(uint(slot) + 1 + i));
+        }
+    }
+
+    function setBytes32(bytes32 slot, bytes32 _value) internal {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+        sstore(slot, _value)
+        }
+    }
+
+    function getBytes32(bytes32 slot) internal view returns (bytes32 str) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+        str := sload(slot)
+        }
+    }
+}

package/contracts/base/upgradability/BaseUpgradeableStrategyV2.sol

@@ -0,0 +1,145 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
+import "./BaseUpgradeableStrategyStorageV2.sol";
+import "../inheritance/ControllableInit.sol";
+import "../interface/IControllerV2.sol";
+import "../interface/IRewardForwarder.sol";
+import "../interface/merkl/IDistributor.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+
+contract BaseUpgradeableStrategyV2 is Initializable, ControllableInit, BaseUpgradeableStrategyStorageV2 {
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  event ProfitsNotCollected(bool sell, bool floor);
+  event ProfitLogInReward(uint256 profitAmount, uint256 feeAmount, uint256 timestamp);
+  event ProfitAndBuybackLog(uint256 profitAmount, uint256 feeAmount, uint256 timestamp);
+
+  modifier restricted() {
+    require(msg.sender == vault() || msg.sender == controller()
+      || msg.sender == governance(),
+      "The sender has to be the controller, governance, or vault");
+    _;
+  }
+
+  // This is only used in `investAllUnderlying()`
+  // The user can still freely withdraw from the strategy
+  modifier onlyNotPausedInvesting() {
+    require(!pausedInvesting(), "Action blocked as the strategy is in emergency state");
+    _;
+  }
+
+  constructor() public BaseUpgradeableStrategyStorageV2() {
+  }
+
+  function initialize(
+    address _storage,
+    address _underlying,
+    address _vault,
+    address _rewardPool,
+    address _rewardToken,
+    address _strategist
+  ) public initializer {
+    ControllableInit.initialize(
+      _storage
+    );
+    _setUnderlying(_underlying);
+    _setVault(_vault);
+    _setRewardPool(_rewardPool);
+    _setRewardToken(_rewardToken);
+    _setStrategist(_strategist);
+    _setSell(true);
+    _setSellFloor(0);
+    _setPausedInvesting(false);
+  }
+
+  /**
+  * Schedules an upgrade for this vault's proxy.
+  */
+  function scheduleUpgrade(address impl) public onlyGovernance {
+    _setNextImplementation(impl);
+    _setNextImplementationTimestamp(block.timestamp.add(nextImplementationDelay()));
+  }
+
+  function _finalizeUpgrade() internal {
+    _setNextImplementation(address(0));
+    _setNextImplementationTimestamp(0);
+  }
+
+  function shouldUpgrade() external view returns (bool, address) {
+    return (
+      nextImplementationTimestamp() != 0
+        && block.timestamp > nextImplementationTimestamp()
+        && nextImplementation() != address(0),
+      nextImplementation()
+    );
+  }
+
+  function toggleMerklOperator(address merklDistr, address _operator) external onlyGovernance {
+    IDistributor(merklDistr).toggleOperator(address(this), _operator);
+  }
+
+  // ========================= Internal & Private Functions =========================
+
+  // ==================== Functionality ====================
+
+  /**
+    * @dev Same as `_notifyProfitAndBuybackInRewardToken` but does not perform a compounding buyback. Just takes fees
+    *      instead.
+    */
+  function _notifyProfitInRewardToken(
+      address _rewardToken,
+      uint256 _rewardBalance
+  ) internal {
+      if (_rewardBalance > 100) {
+          uint _feeDenominator = feeDenominator();
+          uint256 strategistFee = _rewardBalance.mul(strategistFeeNumerator()).div(_feeDenominator);
+          uint256 platformFee = _rewardBalance.mul(platformFeeNumerator()).div(_feeDenominator);
+          uint256 profitSharingFee = _rewardBalance.mul(profitSharingNumerator()).div(_feeDenominator);
+
+          address strategyFeeRecipient = strategist();
+          address platformFeeRecipient = IControllerV2(controller()).governance();
+
+          emit ProfitLogInReward(
+              _rewardToken,
+              _rewardBalance,
+              profitSharingFee,
+              block.timestamp
+          );
+          emit PlatformFeeLogInReward(
+              platformFeeRecipient,
+              _rewardToken,
+              _rewardBalance,
+              platformFee,
+              block.timestamp
+          );
+          emit StrategistFeeLogInReward(
+              strategyFeeRecipient,
+              _rewardToken,
+              _rewardBalance,
+              strategistFee,
+              block.timestamp
+          );
+
+          address rewardForwarder = IControllerV2(controller()).rewardForwarder();
+          IERC20(_rewardToken).safeApprove(rewardForwarder, 0);
+          IERC20(_rewardToken).safeApprove(rewardForwarder, _rewardBalance);
+
+          // Distribute/send the fees
+          IRewardForwarder(rewardForwarder).notifyFee(
+              _rewardToken,
+              profitSharingFee,
+              strategistFee,
+              platformFee
+          );
+      } else {
+          emit ProfitLogInReward(_rewardToken, 0, 0, block.timestamp);
+          emit PlatformFeeLogInReward(IControllerV2(controller()).governance(), _rewardToken, 0, 0, block.timestamp);
+          emit StrategistFeeLogInReward(strategist(), _rewardToken, 0, 0, block.timestamp);
+      }
+  }
+}

package/contracts/base/upgradability/IUpgradable.sol

@@ -0,0 +1,7 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+interface IUpgradeableStrategy {
+  function scheduleUpgrade(address impl) external;
+  function upgrade() external;
+}

package/contracts/base/upgradability/Proxy.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.12;
+
+/**
+ * @title Proxy
+ * @dev Implements delegation of calls to other contracts, with proper
+ * forwarding of return values and bubbling of failures.
+ * It defines a fallback function that delegates all calls to the address
+ * returned by the abstract _implementation() internal function.
+ */
+abstract contract Proxy {
+  /**
+   * @dev Fallback function.
+   * Implemented entirely in `_fallback`.
+   */
+  fallback () payable external {
+    _fallback();
+  }
+
+  receive () payable external {}
+
+  /**
+   * @return The Address of the implementation.
+   */
+  function _implementation() internal view virtual returns (address);
+
+  /**
+   * @dev Delegates execution to an implementation contract.
+   * This is a low level function that doesn't return to its internal call site.
+   * It will return to the external caller whatever the implementation returns.
+   * @param implementation Address to delegate.
+   */
+  function _delegate(address implementation) internal {
+    assembly {
+      // Copy msg.data. We take full control of memory in this inline assembly
+      // block because it will not return to Solidity code. We overwrite the
+      // Solidity scratch pad at memory position 0.
+      calldatacopy(0, 0, calldatasize())
+
+      // Call the implementation.
+      // out and outsize are 0 because we don't know the size yet.
+      let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
+
+      // Copy the returned data.
+      returndatacopy(0, 0, returndatasize())
+
+      switch result
+      // delegatecall returns 0 on error.
+      case 0 { revert(0, returndatasize()) }
+      default { return(0, returndatasize()) }
+    }
+  }
+
+  /**
+   * @dev Function that is run as the first thing in the fallback function.
+   * Can be redefined in derived contracts to add functionality.
+   * Redefinitions must call super._willFallback().
+   */
+  function _willFallback() internal {
+  }
+
+  /**
+   * @dev fallback implementation.
+   * Extracted to enable manual triggering.
+   */
+  function _fallback() internal {
+    _willFallback();
+    _delegate(_implementation());
+  }
+}