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

package/contracts/base/inheritance/RewardTokenProfitNotifier.sol

@@ -0,0 +1,48 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
+import "../interface/IController.sol";
+import "./Controllable.sol";
+
+contract RewardTokenProfitNotifier is Controllable {
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  uint256 public profitSharingNumerator;
+  uint256 public profitSharingDenominator;
+  address public rewardToken;
+
+  constructor(
+    address _storage,
+    address _rewardToken
+  ) public Controllable(_storage){
+    rewardToken = _rewardToken;
+    // persist in the state for immutability of the fee
+    profitSharingNumerator = 80;
+    profitSharingDenominator = 1000;
+    require(profitSharingNumerator < profitSharingDenominator, "invalid profit share");
+  }
+
+  event ProfitLogInReward(uint256 profitAmount, uint256 feeAmount, uint256 timestamp);
+  event ProfitAndBuybackLog(uint256 profitAmount, uint256 feeAmount, uint256 timestamp);
+
+  function notifyProfitInRewardToken(uint256 _rewardBalance) internal {
+    if( _rewardBalance > 0 ){
+      uint256 feeAmount = _rewardBalance.mul(profitSharingNumerator).div(profitSharingDenominator);
+      emit ProfitLogInReward(_rewardBalance, feeAmount, block.timestamp);
+      IERC20(rewardToken).safeApprove(controller(), 0);
+      IERC20(rewardToken).safeApprove(controller(), feeAmount);
+
+      IController(controller()).notifyFee(
+        rewardToken,
+        feeAmount
+      );
+    } else {
+      emit ProfitLogInReward(0, 0, block.timestamp);
+    }
+  }
+}

package/contracts/base/inheritance/Storage.sol

@@ -0,0 +1,36 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+contract Storage {
+
+  address public governance;
+  address public controller;
+
+  constructor() public {
+    governance = msg.sender;
+  }
+
+  modifier onlyGovernance() {
+    require(isGovernance(msg.sender), "Not governance");
+    _;
+  }
+
+  function setGovernance(address _governance) public onlyGovernance {
+    require(_governance != address(0), "new governance shouldn't be empty");
+    governance = _governance;
+  }
+
+  function setController(address _controller) public onlyGovernance {
+    require(_controller != address(0), "new controller shouldn't be empty");
+    controller = _controller;
+  }
+
+  function isGovernance(address account) public view returns (bool) {
+    return account == governance;
+  }
+
+  function isController(address account) public view returns (bool) {
+    return account == controller;
+  }
+}

package/contracts/base/interface/IController.sol

@@ -0,0 +1,30 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface IController {
+    // [Grey list]
+    // An EOA can safely interact with the system no matter what.
+    // If you're using Metamask, you're using an EOA.
+    // Only smart contracts may be affected by this grey list.
+    //
+    // This contract will not be able to ban any EOA from the system
+    // even if an EOA is being added to the greyList, he/she will still be able
+    // to interact with the whole system as if nothing happened.
+    // Only smart contracts will be affected by being added to the greyList.
+    // This grey list is only used in Vault.sol, see the code there for reference
+    function greyList(address _target) external view returns(bool);
+
+    function addVaultAndStrategy(address _vault, address _strategy) external;
+    function doHardWork(address _vault) external;
+
+    function salvage(address _token, uint256 amount) external;
+    function salvageStrategy(address _strategy, address _token, uint256 amount) external;
+
+    function notifyFee(address _underlying, uint256 fee) external;
+    function profitSharingNumerator() external view returns (uint256);
+    function profitSharingDenominator() external view returns (uint256);
+
+    function feeRewardForwarder() external view returns(address);
+    function setFeeRewardForwarder(address _value) external;
+}

package/contracts/base/interface/IControllerV2.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+
+interface IControllerV2 {
+
+    // ========================= Events =========================
+
+    event QueueProfitSharingChange(uint profitSharingNumerator, uint validAtTimestamp);
+    event ConfirmProfitSharingChange(uint profitSharingNumerator);
+
+    event QueueStrategistFeeChange(uint strategistFeeNumerator, uint validAtTimestamp);
+    event ConfirmStrategistFeeChange(uint strategistFeeNumerator);
+
+    event QueuePlatformFeeChange(uint platformFeeNumerator, uint validAtTimestamp);
+    event ConfirmPlatformFeeChange(uint platformFeeNumerator);
+
+    event QueueNextImplementationDelay(uint implementationDelay, uint validAtTimestamp);
+    event ConfirmNextImplementationDelay(uint implementationDelay);
+
+    event AddedStakingContract(address indexed stakingContract);
+    event RemovedStakingContract(address indexed stakingContract);
+
+    event SharePriceChangeLog(
+        address indexed vault,
+        address indexed strategy,
+        uint256 oldSharePrice,
+        uint256 newSharePrice,
+        uint256 timestamp
+    );
+
+    // ==================== Functions ====================
+
+    /**
+     * An EOA can safely interact with the system no matter what. If you're using Metamask, you're using an EOA. Only
+     * smart contracts may be affected by this grey list. This contract will not be able to ban any EOA from the system
+     * even if an EOA is being added to the greyList, he/she will still be able to interact with the whole system as if
+     * nothing happened. Only smart contracts will be affected by being added to the greyList. This grey list is only
+     * used in VaultV3.sol, see the code there for reference
+     */
+    function greyList(address _target) external view returns (bool);
+
+    function addressWhiteList(address _target) external view returns (bool);
+
+    function codeWhiteList(address _target) external view returns (bool);
+
+    function addToWhitelist(address _target) external;
+
+    function addCodeToWhitelist(address _target) external;
+
+    function store() external view returns (address);
+
+    function governance() external view returns (address);
+
+    function notifyFee(address _underlying, uint256 fee) external;
+
+    function doHardWork(address _vault) external;
+
+    function addHardWorker(address _worker) external;
+
+    function removeHardWorker(address _worker) external;
+
+    function salvage(address _token, uint256 amount) external;
+
+    function salvageStrategy(address _strategy, address _token, uint256 amount) external;
+
+    /**
+     * @return The targeted profit token to convert all-non-compounding rewards to. Defaults to WETH.
+     */
+    function targetToken() external view returns (address);
+
+    function setTargetToken(address _targetToken) external;
+
+    function profitSharingReceiver() external view returns (address);
+
+    function setProfitSharingReceiver(address _profitSharingReceiver) external;
+
+    function protocolFeeReceiver() external view returns (address);
+
+    function setProtocolFeeReceiver(address _protocolFeeReceiver) external;
+
+    function rewardForwarder() external view returns (address);
+
+    function setRewardForwarder(address _rewardForwarder) external;
+
+    function universalLiquidator() external view returns (address);
+
+    function setUniversalLiquidator(address _universalLiquidator) external;
+
+    function dolomiteYieldFarmingRouter() external view returns (address);
+
+    function setDolomiteYieldFarmingRouter(address _value) external;
+
+    function nextImplementationDelay() external view returns (uint256);
+
+    function profitSharingNumerator() external view returns (uint256);
+
+    function strategistFeeNumerator() external view returns (uint256);
+
+    function platformFeeNumerator() external view returns (uint256);
+
+    function feeDenominator() external view returns (uint256);
+
+    function setProfitSharingNumerator(uint _profitSharingNumerator) external;
+
+    function confirmSetProfitSharingNumerator() external;
+
+    function setStrategistFeeNumerator(uint _strategistFeeNumerator) external;
+
+    function confirmSetStrategistFeeNumerator() external;
+
+    function setPlatformFeeNumerator(uint _platformFeeNumerator) external;
+
+    function confirmSetPlatformFeeNumerator() external;
+
+    function setNextImplementationDelay(uint256 _nextImplementationDelay) external;
+
+    function confirmNextImplementationDelay() external;
+
+    function nextProfitSharingNumerator() external view returns (uint256);
+
+    function nextProfitSharingNumeratorTimestamp() external view returns (uint256);
+
+    function nextStrategistFeeNumerator() external view returns (uint256);
+
+    function nextStrategistFeeNumeratorTimestamp() external view returns (uint256);
+
+    function nextPlatformFeeNumerator() external view returns (uint256);
+
+    function nextPlatformFeeNumeratorTimestamp() external view returns (uint256);
+
+    function tempNextImplementationDelay() external view returns (uint256);
+
+    function tempNextImplementationDelayTimestamp() external view returns (uint256);
+}

package/contracts/base/interface/IERC4626.sol

@@ -0,0 +1,263 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.12;
+
+
+interface IERC4626 {
+
+    // ========================= Events =========================
+
+    /**
+     * Caller has exchanged assets for shares, and transferred those shares to owner.
+     *
+     * MUST be emitted when tokens are deposited into the Vault via the mint and deposit methods.
+     */
+    event Deposit(
+        address indexed sender,
+        address indexed receiver,
+        uint256 assets,
+        uint256 shares
+    );
+
+    /**
+     * Caller has exchanged shares, owned by owner, for assets, and transferred those assets to receiver.
+     *
+     * MUST be emitted when shares are withdrawn from the Vault in ERC4626.redeem or ERC4626.withdraw methods.
+     */
+    event Withdraw(
+        address indexed sender,
+        address indexed receiver,
+        address indexed owner,
+        uint256 assets,
+        uint256 shares
+    );
+
+    // ========================= Functions =========================
+
+    /**
+     * @return assetTokenAddress The address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
+     */
+    function asset() external view returns (address assetTokenAddress);
+
+    /**
+     * @return  totalManagedAssets Total amount of the underlying asset that is “managed” by Vault. SHOULD include any compounding that
+     *          occurs from yield. MUST be inclusive of any fees that are charged against assets in the Vault.
+     */
+    function totalAssets() external view returns (uint256 totalManagedAssets);
+
+    /**
+     * @return  assetsPerUnitShare The amount of underlying the Vault would exchange for 1 unit of shares, in an ideal scenario where all
+     *          the conditions are met. MUST NOT be inclusive of any fees that are charged against assets in the Vault.
+     *          MUST NOT show any variations depending on the caller. MUST NOT reflect slippage or other on-chain
+     *          conditions, when performing the actual exchange. MUST NOT revert unless due to integer overflow caused
+     *          by an unreasonably large input. MUST round down towards 0. This calculation MAY NOT reflect the
+     *          “per-user” price-per-share, and instead should reflect the “average-user’s” price-per-share, meaning
+     *          what the average user should expect to see when exchanging to and from. This function should normally
+     *          return more than `10 ** underlying().decimals`.
+     */
+    function assetsPerShare() external view returns (uint256 assetsPerUnitShare);
+
+    /**
+     * @return  assets Total amount of the underlying asset that is “managed” by Vault for the `depositor`. SHOULD include any
+     *          compounding that occurs from yield. MUST be inclusive of any fees that are charged against assets in the
+     *          Vault.
+     */
+    function assetsOf(address depositor) external view returns (uint256 assets);
+
+    /**
+     * Maximum amount of the underlying asset that can be deposited into the Vault for the receiver, through a deposit
+     * call. MUST return the maximum amount of assets deposit would allow to be deposited for receiver and not cause a
+     * revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if
+     * necessary). This assumes that the user has infinite assets, i.e. MUST NOT rely on balanceOf of asset. MUST factor
+     * in both global and user-specific limits, like if deposits are entirely disabled (even temporarily) it MUST return
+     * 0. MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
+     */
+    function maxDeposit(address caller) external view returns (uint256 maxAssets);
+
+    /**
+     * Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current
+     * on-chain conditions.
+     *
+     * MUST return as close to and no more than the exact amount of Vault shares that would be
+     * minted in a deposit call in the same transaction. I.e. deposit should return the same or more shares as
+     * previewDeposit if called in the same transaction. MUST NOT account for deposit limits like those returned from
+     * maxDeposit and should always act as though the deposit would be accepted, regardless if the user has enough
+     * tokens approved, etc.
+     *
+     * MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
+     *
+     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
+     * cause deposit to revert.
+     *
+     * Note that any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
+     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
+     */
+    function previewDeposit(uint256 assets) external view returns (uint256 shares);
+
+    /**
+     * Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
+     *
+     * MUST emit the Deposit event.
+     *
+     * MUST support ERC-20 approve / transferFrom on asset as a deposit flow. MAY support an additional flow in which
+     * the underlying tokens are owned by the Vault contract before the deposit execution, and are accounted for during
+     * deposit.
+     *
+     * MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
+     * approving enough underlying tokens to the Vault contract, etc).
+     *
+     * Note that most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
+     */
+    function deposit(uint256 assets, address receiver) external returns (uint256 shares);
+
+    /**
+     * Maximum amount of shares that can be minted from the Vault for the receiver, through a mint call.
+     *
+     * MUST return the maximum amount of shares mint would allow to be deposited to receiver and not cause a revert,
+     * which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if necessary).
+     * This assumes that the user has infinite assets, i.e. MUST NOT rely on balanceOf of asset.
+     *
+     * MUST factor in both global and user-specific limits, like if mints are entirely disabled (even temporarily) it
+     * MUST return 0.
+     *
+     * MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
+     */
+    function maxMint(address caller) external view returns (uint256 maxShares);
+
+    /**
+     * Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current
+     * on-chain conditions.
+     *
+     * MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call in
+     * the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the same
+     * transaction.
+     *
+     * MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint would
+     * be accepted, regardless if the user has enough tokens approved, etc.
+     *
+     * MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
+     *
+     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
+     * cause mint to revert.
+     *
+     * Note that any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
+     * share price or some other type of condition, meaning the depositor will lose assets by minting.
+     */
+    function previewMint(uint256 shares) external view returns (uint256 assets);
+
+    /**
+     * Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
+     *
+     * MUST emit the Deposit event.
+     *
+     * MUST support ERC-20 approve / transferFrom on asset as a mint flow. MAY support an additional flow in which the
+     * underlying tokens are owned by the Vault contract before the mint execution, and are accounted for during mint.
+     *
+     * MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
+     * approving enough underlying tokens to the Vault contract, etc).
+     *
+     * Note that most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
+     */
+    function mint(uint256 shares, address receiver) external returns (uint256 assets);
+
+    /**
+     * Maximum amount of the underlying asset that can be withdrawn from the owner balance in the Vault, through a
+     * withdraw call.
+     *
+     * MUST return the maximum amount of assets that could be transferred from owner through withdraw and not cause a
+     * revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if
+     * necessary).
+     *
+     * MUST factor in both global and user-specific limits, like if withdrawals are entirely disabled (even temporarily)
+     * it MUST return 0.
+     */
+    function maxWithdraw(address caller) external view returns (uint256 maxAssets);
+
+    /**
+     * Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given
+     * current on-chain conditions.
+     *
+     * MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
+     * call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if called
+     * in the same transaction.
+     *
+     * MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though the
+     * withdrawal would be accepted, regardless if the user has enough shares, etc.
+     *
+     * MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
+     *
+     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
+     * cause withdraw to revert.
+     *
+     * Note that any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage
+     * in share price or some other type of condition, meaning the depositor will lose assets by depositing.
+     */
+    function previewWithdraw(uint256 assets) external view returns (uint256 shares);
+
+    /**
+     * Burns shares from owner and sends exactly assets of underlying tokens to receiver.
+     *
+     * MUST emit the Withdraw event.
+     *
+     * MUST support a withdraw flow where the shares are burned from owner directly where owner is msg.sender or
+     * msg.sender has ERC-20 approval over the shares of owner. MAY support an additional flow in which the shares are
+     * transferred to the Vault contract before the withdraw execution, and are accounted for during withdraw.
+     *
+     * MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner not
+     * having enough shares, etc).
+     *
+     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
+     * Those methods should be performed separately.
+     */
+    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
+
+    /**
+     * Maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, through a redeem call.
+     *
+     * MUST return the maximum amount of shares that could be transferred from owner through redeem and not cause a
+     * revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if
+     * necessary).
+     *
+     * MUST factor in both global and user-specific limits, like if redemption is entirely disabled (even temporarily)
+     * it MUST return 0.
+     */
+    function maxRedeem(address caller) external view returns (uint256 maxShares);
+
+    /**
+     * Allows an on-chain or off-chain user to simulate the effects of their redemption at the current block, given
+     * current on-chain conditions.
+     *
+     * MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call in
+     * the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the same
+     * transaction.
+     *
+     * MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
+     * redemption would be accepted, regardless if the user has enough shares, etc.
+     *
+     * MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
+     *
+     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
+     * cause redeem to revert.
+     *
+     * Note that any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
+     * share price or some other type of condition, meaning the depositor will lose assets by redeeming.
+     */
+    function previewRedeem(uint256 shares) external view returns (uint256 assets);
+
+    /**
+     * Burns exactly shares from owner and sends assets of underlying tokens to receiver.
+     *
+     * MUST emit the Withdraw event.
+     *
+     * MUST support a redeem flow where the shares are burned from owner directly where owner is msg.sender or
+     * msg.sender has ERC-20 approval over the shares of owner. MAY support an additional flow in which the shares are
+     * transferred to the Vault contract before the redeem execution, and are accounted for during redeem.
+     *
+     * MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner not
+     * having enough shares, etc).
+     *
+     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
+     * Those methods should be performed separately.
+     */
+    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
+}

package/contracts/base/interface/IFeeRewardForwarder.sol

@@ -0,0 +1,9 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface IFeeRewardForwarder {
+    function poolNotifyFixedTarget(address _token, uint256 _amount) external;
+    function profitSharingPool() external view returns (address);
+    function setConversionPath(address[] calldata _route, address[] calldata _routers) external;
+}

package/contracts/base/interface/IProfitSharingReceiver.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+
+interface IProfitSharingReceiver {
+
+    function governance() external view returns (address);
+
+    function withdrawTokens(address[] calldata _tokens) external;
+}

package/contracts/base/interface/IRewardForwarder.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.6.12;
+
+
+/**
+ * @dev A routing contract that is responsible for taking the harvested gains and routing them into FARM and additional
+ *      buyback tokens for the corresponding strategy
+ */
+interface IRewardForwarder {
+
+    function store() external view returns (address);
+
+    function governance() external view returns (address);
+
+    /**
+     * @dev This function sends converted `_buybackTokens` to `msg.sender`. The returned amounts will match the
+     *      `amounts` return value. The fee amounts are converted to the profit sharing token and sent to the proper
+     *      addresses (profit sharing, strategist, and governance (platform)).
+     *
+     * @param _token            the token that will be compounded or sold into the profit sharing token for the Harvest
+     *                          collective (users that stake iFARM)
+     * @param _profitSharingFee the amount of `_token` that will be sold into the profit sharing token
+     * @param _strategistFee    the amount of `_token` that will be sold into the profit sharing token for the
+     *                          strategist
+     * @param _platformFee      the amount of `_token` that will be sold into the profit sharing token for the Harvest
+     *                          treasury
+     * @param _buybackTokens    the output tokens that `_buyBackAmounts` should be swapped to (outputToken)
+     * @param _buybackAmounts   the amounts of `_token` that will be bought into more `_buybackTokens` token
+     * @return amounts The amounts that were purchased of _buybackTokens
+     */
+    function notifyFeeAndBuybackAmounts(
+        address _token,
+        uint256 _profitSharingFee,
+        uint256 _strategistFee,
+        uint256 _platformFee,
+        address[] calldata _buybackTokens,
+        uint256[] calldata _buybackAmounts
+    ) external returns (uint[] memory amounts);
+
+    /**
+     * @dev This function converts the fee amounts to the profit sharing token and sends them to the proper addresses
+     *      (profit sharing, strategist, and governance (platform)).
+     *
+     * @param _token            the token that will be compounded or sold into the profit sharing token for the Harvest
+     *                          collective (users that stake iFARM)
+     * @param _profitSharingFee the amount of `_token` that will be sold into the profit sharing token
+     * @param _strategistFee    the amount of `_token` that will be sold into the profit sharing token for the
+     *                          strategist
+     * @param _platformFee      the amount of `_token` that will be sold into the profit sharing token for the Harvest
+     *                          treasury
+     */
+    function notifyFee(
+        address _token,
+        uint256 _profitSharingFee,
+        uint256 _strategistFee,
+        uint256 _platformFee
+    ) external;
+}

package/contracts/base/interface/IRewardPool.sol

@@ -0,0 +1,34 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+// Unifying the interface with the Synthetix Reward Pool
+interface IRewardPool {
+  function rewardToken() external view returns (address);
+  function lpToken() external view returns (address);
+  function duration() external view returns (uint256);
+
+  function periodFinish() external view returns (uint256);
+  function rewardRate() external view returns (uint256);
+  function rewardPerTokenStored() external view returns (uint256);
+
+  function stake(uint256 amountWei) external;
+
+  // `balanceOf` would give the amount staked.
+  // As this is 1 to 1, this is also the holder's share
+  function balanceOf(address holder) external view returns (uint256);
+  // total shares & total lpTokens staked
+  function totalSupply() external view returns(uint256);
+
+  function withdraw(uint256 amountWei) external;
+  function exit() external;
+
+  // get claimed rewards
+  function earned(address holder) external view returns (uint256);
+
+  // claim rewards
+  function getReward() external;
+
+  // notify
+  function notifyRewardAmount(uint256 _amount) external;
+}

package/contracts/base/interface/IStrategy.sol

@@ -0,0 +1,25 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface IStrategy {
+
+    function unsalvagableTokens(address tokens) external view returns (bool);
+
+    function underlying() external view returns (address);
+    function vault() external view returns (address);
+
+    function withdrawAllToVault() external;
+    function withdrawToVault(uint256 amount) external;
+
+    function investedUnderlyingBalance() external view returns (uint256); // itsNotMuch()
+
+    // should only be called by controller
+    function salvage(address recipient, address token, uint256 amount) external;
+
+    function doHardWork() external;
+    function depositArbCheck() external view returns(bool);
+
+    function strategist() external view returns (address);
+    function salvageToken(address recipient, address token, uint amount) external;
+}

package/contracts/base/interface/IUniversalLiquidator.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.12;
+
+interface IUniversalLiquidator {
+    event Swap(
+        address indexed sellToken,
+        address indexed buyToken,
+        address indexed receiver,
+        address initiator,
+        uint256 sellAmount,
+        uint256 minBuyAmount
+    );
+
+    function swap(
+        address _sellToken,
+        address _buyToken,
+        uint256 _sellAmount,
+        uint256 _minBuyAmount,
+        address _receiver
+    ) external returns (uint256);
+}