@harvest-finance/harvest-strategy-arbitrum 0.0.1-security → 1.0.1

package/contracts/base/interface/notional/INProxy.sol

@@ -0,0 +1,44 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface INProxy {
+    /// @notice Specifies different deposit actions that can occur during BalanceAction or BalanceActionWithTrades
+    enum DepositActionType {
+        // No deposit action
+        None,
+        // Deposit asset cash, depositActionAmount is specified in asset cash external precision
+        DepositAsset,
+        // Deposit underlying tokens that are mintable to asset cash, depositActionAmount is specified in underlying token
+        // external precision
+        DepositUnderlying,
+        // Deposits specified asset cash external precision amount into an nToken and mints the corresponding amount of
+        // nTokens into the account
+        DepositAssetAndMintNToken,
+        // Deposits specified underlying in external precision, mints asset cash, and uses that asset cash to mint nTokens
+        DepositUnderlyingAndMintNToken,
+        // Redeems an nToken balance to asset cash. depositActionAmount is specified in nToken precision. Considered a deposit action
+        // because it deposits asset cash into an account. If there are fCash residuals that cannot be sold off, will revert.
+        RedeemNToken,
+        // Converts specified amount of asset cash balance already in Notional to nTokens. depositActionAmount is specified in
+        // Notional internal 8 decimal precision.
+        ConvertCashToNToken
+    }
+    /// @notice Defines a balance action for batchAction
+    struct BalanceAction {
+        // Deposit action to take (if any)
+        DepositActionType actionType;
+        uint16 currencyId;
+        // Deposit action amount must correspond to the depositActionType, see documentation above.
+        uint256 depositActionAmount;
+        // Withdraw an amount of asset cash specified in Notional internal 8 decimal precision
+        uint256 withdrawAmountInternalPrecision;
+        // If set to true, will withdraw entire cash balance. Useful if there may be an unknown amount of asset cash
+        // residual left from trading.
+        bool withdrawEntireCashBalance;
+        // If set to true, will redeem asset cash to the underlying token on withdraw.
+        bool redeemToUnderlying;
+    }
+    function getCurrencyId(address token) external view returns(uint16 currencyId);
+    function batchBalanceAction(address account, BalanceAction[] calldata actions) external payable;
+    function nTokenClaimIncentives() external;
+}

package/contracts/base/interface/notional/IPrimeToken.sol

@@ -0,0 +1,6 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IPrimeToken {
+    function asset() external view returns(address);
+}

package/contracts/base/interface/venus/IRewardsDistributor.sol

@@ -0,0 +1,6 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IRewardsDistributor {
+    function claimRewardToken(address holder) external;
+}

package/contracts/base/interface/weth/IWETH.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Unlicense
+// based on https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code
+
+/**
+ *Submitted for verification at Etherscan.io on 2017-12-12
+*/
+
+// Copyright (C) 2015, 2016, 2017 Dapphub
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+pragma solidity 0.8.26;
+
+interface IWETH {
+
+    function balanceOf(address target) external view returns (uint256);
+
+    function deposit() external payable ;
+
+    function withdraw(uint wad) external ;
+
+    function totalSupply() external view returns (uint) ;
+
+    function approve(address guy, uint wad) external returns (bool) ;
+
+    function transfer(address dst, uint wad) external returns (bool) ;
+
+    function transferFrom(address src, address dst, uint wad) external returns (bool);
+}

package/contracts/base/ipor/Erc4626BalanceFuse.sol

@@ -0,0 +1,54 @@
+
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
+import {IMarketBalanceFuse} from "../interface/ipor/IMarketBalanceFuse.sol";
+import {IPriceOracleMiddleware} from "../interface/ipor/IPriceOracleMiddleware.sol";
+import {PlasmaVaultConfigLib} from "../interface/ipor/PlasmaVaultConfigLib.sol";
+import {IporMath} from "../interface/ipor/IporMath.sol";
+import {PlasmaVaultLib} from "../interface/ipor/PlasmaVaultLib.sol";
+
+/// @title Generic fuse for ERC4626 vaults responsible for calculating the balance of the Plasma Vault in the ERC4626 vaults based on preconfigured market substrates
+/// @dev Substrates in this fuse are the assets that are used in the ERC4626 vaults for a given MARKET_ID
+contract Erc4626BalanceFuse is IMarketBalanceFuse {
+    using SafeCast for uint256;
+
+    uint256 public immutable MARKET_ID;
+
+    constructor(uint256 marketId_) {
+        MARKET_ID = marketId_;
+    }
+
+    /// @return The balance of the Plasma Vault in associated with Fuse Balance marketId in USD, represented in 18 decimals
+    function balanceOf() external view override returns (uint256) {
+        bytes32[] memory vaults = PlasmaVaultConfigLib.getMarketSubstrates(MARKET_ID);
+
+        uint256 len = vaults.length;
+
+        if (len == 0) {
+            return 0;
+        }
+
+        uint256 balance;
+        uint256 vaultAssets;
+        IERC4626 vault;
+        address asset;
+        uint256 price;
+        uint256 priceDecimals;
+        address priceOracleMiddleware = PlasmaVaultLib.getPriceOracleMiddleware();
+        address plasmaVault = address(this);
+
+        for (uint256 i; i < len; ++i) {
+            vault = IERC4626(PlasmaVaultConfigLib.bytes32ToAddress(vaults[i]));
+            vaultAssets = vault.convertToAssets(vault.balanceOf(plasmaVault));
+            asset = vault.asset();
+            (price, priceDecimals) = IPriceOracleMiddleware(priceOracleMiddleware).getAssetPrice(asset);
+            balance += IporMath.convertToWad(vaultAssets * price, IERC20Metadata(asset).decimals() + priceDecimals);
+        }
+
+        return balance;
+    }
+}

package/contracts/base/ipor/Erc4626SupplyFuse.sol

@@ -0,0 +1,134 @@
+
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {IFuseCommon} from "../interface/ipor/IFuseCommon.sol";
+import {IporMath} from "../interface/ipor/IporMath.sol";
+import {IFuseInstantWithdraw} from "../interface/ipor/IFuseInstantWithdraw.sol";
+import {PlasmaVaultConfigLib} from "../interface/ipor/PlasmaVaultConfigLib.sol";
+
+/// @notice Data structure for entering - supply - the ERC4626 vault
+struct Erc4626SupplyFuseEnterData {
+    /// @dev ERC4626 vault address
+    address vault;
+    /// @dev amount to supply, this is amount of underlying asset in the given ERC4626 vault
+    uint256 vaultAssetAmount;
+}
+
+/// @notice Data structure for exiting - withdrawing - the ERC4626 vault
+struct Erc4626SupplyFuseExitData {
+    /// @dev ERC4626 vault address
+    address vault;
+    /// @dev amount to withdraw, this is amount of underlying asset in the given ERC4626 vault
+    uint256 vaultAssetAmount;
+}
+
+/// @title Generic fuse for ERC4626 vaults responsible for supplying and withdrawing assets from the ERC4626 vaults based on preconfigured market substrates
+/// @dev Substrates in this fuse are the assets that are used in the ERC4626 vaults for a given MARKET_ID
+contract Erc4626SupplyFuse is IFuseCommon, IFuseInstantWithdraw {
+    using SafeCast for uint256;
+    using SafeERC20 for ERC20;
+
+    event Erc4626SupplyFuseEnter(address version, address asset, address vault, uint256 vaultAssetAmount);
+    event Erc4626SupplyFuseExit(
+        address version,
+        address asset,
+        address vault,
+        uint256 vaultAssetAmount,
+        uint256 shares
+    );
+    event Erc4626SupplyFuseExitFailed(address version, address asset, address vault, uint256 vaultAssetAmount);
+
+    error Erc4626SupplyFuseUnsupportedVault(string action, address asset);
+
+    address public immutable VERSION;
+    uint256 public immutable MARKET_ID;
+
+    constructor(uint256 marketId_) {
+        VERSION = address(this);
+        MARKET_ID = marketId_;
+    }
+
+    function enter(Erc4626SupplyFuseEnterData memory data_) external {
+        if (data_.vaultAssetAmount == 0) {
+            return;
+        }
+
+        if (!PlasmaVaultConfigLib.isSubstrateAsAssetGranted(MARKET_ID, data_.vault)) {
+            revert Erc4626SupplyFuseUnsupportedVault("enter", data_.vault);
+        }
+
+        address underlyingAsset = IERC4626(data_.vault).asset();
+
+        uint256 finalVaultAssetAmount = IporMath.min(
+            data_.vaultAssetAmount,
+            IERC4626(underlyingAsset).balanceOf(address(this))
+        );
+
+        if (finalVaultAssetAmount == 0) {
+            return;
+        }
+
+        ERC20(underlyingAsset).forceApprove(data_.vault, finalVaultAssetAmount);
+
+        IERC4626(data_.vault).deposit(finalVaultAssetAmount, address(this));
+
+        emit Erc4626SupplyFuseEnter(VERSION, underlyingAsset, data_.vault, finalVaultAssetAmount);
+    }
+
+    function exit(Erc4626SupplyFuseExitData calldata data_) external {
+        _exit(data_);
+    }
+
+    /// @dev params[0] - amount in underlying asset, params[1] - vault address
+    function instantWithdraw(bytes32[] calldata params_) external override {
+        uint256 amount = uint256(params_[0]);
+
+        address vault = PlasmaVaultConfigLib.bytes32ToAddress(params_[1]);
+
+        _exit(Erc4626SupplyFuseExitData(vault, amount));
+    }
+
+    function _exit(Erc4626SupplyFuseExitData memory data_) internal {
+        if (data_.vaultAssetAmount == 0) {
+            return;
+        }
+
+        if (!PlasmaVaultConfigLib.isSubstrateAsAssetGranted(MARKET_ID, data_.vault)) {
+            revert Erc4626SupplyFuseUnsupportedVault("exit", data_.vault);
+        }
+
+        uint256 finalVaultAssetAmount = IporMath.min(
+            data_.vaultAssetAmount,
+            IERC4626(data_.vault).convertToAssets(IERC4626(data_.vault).balanceOf(address(this)))
+        );
+
+        if (finalVaultAssetAmount == 0) {
+            return;
+        }
+
+        try IERC4626(data_.vault).withdraw(finalVaultAssetAmount, address(this), address(this)) returns (
+            uint256 shares
+        ) {
+            emit Erc4626SupplyFuseExit(
+                VERSION,
+                IERC4626(data_.vault).asset(),
+                data_.vault,
+                finalVaultAssetAmount,
+                shares
+            );
+        } catch {
+            /// @dev if withdraw failed, continue with the next step
+            emit Erc4626SupplyFuseExitFailed(
+                VERSION,
+                IERC4626(data_.vault).asset(),
+                data_.vault,
+                finalVaultAssetAmount
+            );
+        }
+    }
+}

package/contracts/base/noop/NoopStrategyUpgradeable.sol

@@ -0,0 +1,90 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts/utils/math/Math.sol";
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../interface/IVault.sol";
+import "../upgradability/BaseUpgradeableStrategy.sol";
+
+contract NoopStrategyUpgradeable is BaseUpgradeableStrategy {
+
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  constructor() BaseUpgradeableStrategy() {}
+
+  function initializeBaseStrategy(
+    address _storage,
+    address _underlying,
+    address _vault
+  ) public initializer {
+
+    require(_vault != address(0), "_vault cannot be empty");
+    require(_underlying == IVault(_vault).underlying(), "underlying mismatch");
+
+    BaseUpgradeableStrategy.initialize(
+      _storage,
+      _underlying,
+      _vault,
+      address(0),
+      address(0),
+      address(0)
+    );
+  }
+
+  function depositArbCheck() public pure returns(bool) {
+    return true;
+  }
+
+  function investedUnderlyingBalance() external view returns (uint256 balance) {
+      balance = IERC20(underlying()).balanceOf(address(this));
+  }
+
+  function unsalvagableTokens(address token) public view returns (bool) {
+    return (token == rewardToken() || token == underlying());
+  }
+
+  /*
+  *   Withdraws all the asset to the vault
+  */
+  function withdrawAllToVault() external restricted {
+    address _underlying = underlying();
+    if (IERC20(_underlying).balanceOf(address(this)) > 0) {
+      IERC20(_underlying).safeTransfer(address(vault()), IERC20(_underlying).balanceOf(address(this)));
+    }
+  }
+
+  /*
+  * Cashes some amount out and withdraws to the vault
+  */
+  function withdrawToVault(uint256 amount) external restricted {
+    address _underlying = underlying();
+    require(IERC20(_underlying).balanceOf(address(this)) >= amount,
+      "insufficient balance for the withdrawal");
+    if (amount > 0) {
+      IERC20(_underlying).safeTransfer(address(vault()), amount);
+    }
+  }
+
+  /*
+  *   Governance or Controller can claim coins that are somehow transferred into the contract
+  *   Note that they cannot come in take away coins that are used and defined in the strategy itself
+  */
+  function salvage(address recipient, address token, uint256 amount) external onlyControllerOrGovernance {
+     // To make sure that governance cannot come in and take away the coins
+    require(!unsalvagableTokens(token), "token is defined as not salvagable");
+    IERC20(token).safeTransfer(recipient, amount);
+  }
+
+  /*
+  * Honest harvesting. It's not much, but it pays off
+  */
+  function doHardWork() external restricted {
+    // a no-op
+  }
+
+  function finalizeUpgrade() external onlyGovernance {
+    _finalizeUpgrade();
+  }
+}

package/contracts/base/upgradability/BaseUpgradeabilityProxy.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+
+/**
+ * @title BaseUpgradeabilityProxy
+ * @dev This contract implements a proxy that allows to change the
+ * implementation address to which it will delegate.
+ * Such a change is called an implementation upgrade.
+ */
+contract BaseUpgradeabilityProxy is Proxy {
+  /**
+   * @dev Emitted when the implementation is upgraded.
+   * @param implementation Address of the new implementation.
+   */
+  event Upgraded(address indexed implementation);
+
+  /**
+   * @dev Storage slot with the address of the current implementation.
+   * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
+   * validated in the constructor.
+   */
+  bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+  /**
+   * @dev Returns the current implementation.
+   * @return impl Address of the current implementation
+   */
+  function _implementation() internal view override returns (address impl) {
+    bytes32 slot = IMPLEMENTATION_SLOT;
+    assembly {
+      impl := sload(slot)
+    }
+  }
+
+  /**
+   * @dev Upgrades the proxy to a new implementation.
+   * @param newImplementation Address of the new implementation.
+   */
+  function _upgradeTo(address newImplementation) internal {
+    _setImplementation(newImplementation);
+    emit Upgraded(newImplementation);
+  }
+
+  /**
+   * @dev Sets the implementation address of the proxy.
+   * @param newImplementation Address of the new implementation.
+   */
+  function _setImplementation(address newImplementation) internal {
+    require(Address.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
+
+    bytes32 slot = IMPLEMENTATION_SLOT;
+
+    assembly {
+      sstore(slot, newImplementation)
+    }
+  }
+}

package/contracts/base/upgradability/BaseUpgradeableStrategy.sol

@@ -0,0 +1,144 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "./BaseUpgradeableStrategyStorage.sol";
+import "../inheritance/ControllableInit.sol";
+import "../interface/IController.sol";
+import "../interface/IRewardForwarder.sol";
+import "../interface/merkl/IDistributor.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/utils/math/SafeMath.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract BaseUpgradeableStrategy is Initializable, ControllableInit, BaseUpgradeableStrategyStorage {
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+
+  event ProfitsNotCollected(bool sell, bool floor);
+  event ProfitLogInReward(uint256 profitAmount, uint256 feeAmount, uint256 timestamp);
+
+  modifier restricted() {
+    require(msg.sender == vault() || msg.sender == controller()
+      || msg.sender == governance(),
+      "not allowed");
+    _;
+  }
+
+  // This is only used in `investAllUnderlying()`
+  // The user can still freely withdraw from the strategy
+  modifier onlyNotPausedInvesting() {
+    require(!pausedInvesting(), "emergency state");
+    _;
+  }
+
+  constructor() BaseUpgradeableStrategyStorage() {
+  }
+
+  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 merklClaim, address operator) external onlyGovernance {
+    IDistributor(merklClaim).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 = IController(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 = IController(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(IController(controller()).governance(), _rewardToken, 0, 0, block.timestamp);
+          emit StrategistFeeLogInReward(strategist(), _rewardToken, 0, 0, block.timestamp);
+      }
+  }
+}