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

package/contracts/base/interface/IERC4626.sol

@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+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/IGMXStrategy.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IGMXStrategy {
+
+    /// @notice declared as public so child contract can call it
+    function isUnsalvageableToken(address token) external view returns (bool);
+
+    function salvageToken(address recipient, address token, uint amount) external;
+
+    function governance() external view returns (address);
+
+    function controller() external view returns (address);
+
+    function underlying() external view returns (address);
+
+    function vault() external view returns (address);
+
+    function withdrawAllToVault() external returns(bytes32);
+
+    function withdrawToVault(uint256 _amount) external returns(bytes32);
+
+    function investedUnderlyingBalance() external view returns (uint256);
+
+    function doHardWork() external returns(bytes32);
+
+    function depositArbCheck() external view returns (bool);
+
+    function strategist() external view returns (address);
+
+    /**
+     * @return  The value of any accumulated rewards that are under control by the strategy. Each index corresponds with
+     *          the tokens in `rewardTokens`. This function is not a `view`, because some protocols, like Curve, need
+     *          writeable functions to get the # of claimable reward tokens
+     */
+    function getRewardPoolValues() external returns (uint256[] memory);
+}

package/contracts/base/interface/IGlobalIncentivesHelper.sol

@@ -0,0 +1,6 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IGlobalIncentivesHelper {
+  function notifyPools(address[] calldata tokens, uint256[] calldata totals, uint256 timestamp) external;
+}

package/contracts/base/interface/IPotPool.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IPotPool {
+
+    function initializePotPool(
+        address[] calldata _rewardTokens,
+        address _lpToken,
+        uint256 _duration,
+        address[] calldata _rewardDistribution,
+        address _storage
+    ) external;
+
+    function lpToken() external view returns (address);
+
+    function duration() external view returns (uint256);
+
+    function stakedBalanceOf(address _user) external view returns (uint);
+
+    function smartContractStakers(address _user) external view returns (bool);
+
+    function rewardTokens(uint _index) external view returns (address);
+
+    function getRewardTokens() external view returns (address[] memory);
+
+    function periodFinishForToken(address _rewardToken) external view returns (uint);
+
+    function rewardRateForToken(address _rewardToken) external view returns (uint);
+
+    function lastUpdateTimeForToken(address _rewardToken) external view returns (uint);
+
+    function rewardPerTokenStoredForToken(address _rewardToken) external view returns (uint);
+
+    function userRewardPerTokenPaidForToken(address _rewardToken, address _user) external view returns (uint);
+
+    function rewardsForToken(address _rewardToken, address _user) external view returns (uint);
+
+    function lastTimeRewardApplicable(address _rewardToken) external view returns (uint256);
+
+    function rewardPerToken(address _rewardToken) external view returns (uint256);
+
+    function stake(uint256 _amount) external;
+
+    function withdraw(uint256 _amount) external;
+
+    function exit() external;
+
+    /**
+     * 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) external;
+
+    function getAllRewards() external;
+
+    function getReward(address _rewardToken) external;
+
+    function addRewardToken(address _rewardToken) external;
+
+    function removeRewardToken(address _rewardToken) external;
+
+    /**
+     * @return If the return value is MAX_UINT256, it means that the specified reward token is not in the list
+     */
+    function getRewardTokenIndex(address _rewardToken) external view returns (uint256);
+
+    function notifyTargetRewardAmount(address _rewardToken, uint256 _reward) external;
+
+    function rewardTokensLength() external view returns (uint256);
+}

package/contracts/base/interface/IProfitSharingReceiver.sol

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

package/contracts/base/interface/IRewardForwarder.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+/**
+ * @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/IStrategy.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IStrategy {
+
+    /// @notice declared as public so child contract can call it
+    function isUnsalvageableToken(address token) external view returns (bool);
+
+    function salvageToken(address recipient, address token, uint amount) external;
+
+    function governance() external view returns (address);
+
+    function controller() external view returns (address);
+
+    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);
+
+    function doHardWork() external;
+
+    function depositArbCheck() external view returns (bool);
+
+    function strategist() external view returns (address);
+
+    /**
+     * @return  The value of any accumulated rewards that are under control by the strategy. Each index corresponds with
+     *          the tokens in `rewardTokens`. This function is not a `view`, because some protocols, like Curve, need
+     *          writeable functions to get the # of claimable reward tokens
+     */
+    function getRewardPoolValues() external returns (uint256[] memory);
+}

package/contracts/base/interface/IUniversalLiquidator.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+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);
+}

package/contracts/base/interface/IUniversalLiquidatorRegistry.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface IUniversalLiquidatorRegistry {
+    
+    function setPath(bytes32 _dex, address[] memory _paths) external;
+
+    function setIntermediateToken(address[] memory _token) external;
+
+    function addDex(bytes32 _name, address _address) external;
+
+    function changeDexAddress(bytes32 _name, address _address) external;
+
+    function getAllDexes() external view returns (bytes32[] memory);
+
+    function getAllIntermediateTokens()
+        external
+        view
+        returns (address[] memory);
+}

package/contracts/base/interface/IUpgradeSource.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IUpgradeSource {
+
+  function shouldUpgrade() external view returns (bool, address);
+
+  function finalizeUpgrade() external;
+}

package/contracts/base/interface/IVault.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IVault {
+
+    function initializeVault(
+        address _storage,
+        address _underlying,
+        uint256 _toInvestNumerator,
+        uint256 _toInvestDenominator
+    ) external;
+
+    function balanceOf(address _holder) external view returns (uint256);
+
+    function underlyingBalanceInVault() external view returns (uint256);
+
+    function underlyingBalanceWithInvestment() external view returns (uint256);
+
+    function governance() external view returns (address);
+
+    function controller() external view returns (address);
+
+    function underlying() external view returns (address);
+
+    function underlyingUnit() external view returns (uint);
+
+    function strategy() external view returns (address);
+
+    function setStrategy(address _strategy) external;
+
+    function announceStrategyUpdate(address _strategy) external;
+
+    function setVaultFractionToInvest(uint256 _numerator, uint256 _denominator) external;
+
+    function deposit(uint256 _amount) external;
+    function deposit(uint256 _amount, address _receiver) external;
+
+    function depositFor(uint256 _amount, address _holder) external;
+
+    function withdrawAll() external;
+
+    function withdraw(uint256 _numberOfShares) external;
+
+    function getPricePerFullShare() external view returns (uint256);
+
+    function underlyingBalanceWithInvestmentForHolder(address _holder) view external returns (uint256);
+
+    /**
+     * The total amount available to be deposited from this vault into the strategy, while adhering to the
+     * `vaultFractionToInvestNumerator` and `vaultFractionToInvestDenominator` rules
+     */
+    function availableToInvestOut() external view returns (uint256);
+
+    /**
+     * This should be callable only by the controller (by the hard worker) or by governance
+     */
+    function doHardWork() external;
+}

package/contracts/base/interface/IVaultGMX.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IVaultGMX {
+        
+    struct PendingAction {
+        bool pending;
+        address sender;
+        address receiver;
+        uint256 amountIn;
+    }
+
+    function initializeVault(
+        address _storage,
+        address _underlying,
+        uint256 _toInvestNumerator,
+        uint256 _toInvestDenominator
+    ) external;
+
+    function balanceOf(address _holder) external view returns (uint256);
+
+    function underlyingBalanceInVault() external view returns (uint256);
+
+    function underlyingBalanceWithInvestment() external view returns (uint256);
+
+    function governance() external view returns (address);
+
+    function controller() external view returns (address);
+
+    function underlying() external view returns (address);
+
+    function underlyingUnit() external view returns (uint);
+
+    function strategy() external view returns (address);
+
+    function setStrategy(address _strategy) external;
+
+    function announceStrategyUpdate(address _strategy) external;
+
+    function setVaultFractionToInvest(uint256 _numerator, uint256 _denominator) external;
+
+    function deposit(uint256 _amount) external;
+    function deposit(uint256 _amount, address _receiver) external;
+
+    function depositFor(uint256 _amount, address _holder) external;
+
+    function withdrawAll() external;
+
+    function withdraw(uint256 _numberOfShares) external;
+
+    function getPricePerFullShare() external view returns (uint256);
+
+    function underlyingBalanceWithInvestmentForHolder(address _holder) view external returns (uint256);
+
+    /**
+     * The total amount available to be deposited from this vault into the strategy, while adhering to the
+     * `vaultFractionToInvestNumerator` and `vaultFractionToInvestDenominator` rules
+     */
+    function availableToInvestOut() external view returns (uint256);
+
+    /**
+     * This should be callable only by the controller (by the hard worker) or by governance
+     */
+    function doHardWork() external;
+
+    function finalizeDeposit(bool success, bytes32 key, uint256 amount) external;
+    function finalizeWithdrawal(bool success, bytes32 key, uint256 amount) external;
+
+    function pendingDeposits(bytes32 key) external view returns (PendingAction memory);
+    function pendingWithdrawals(bytes32 key) external view returns (PendingAction memory);
+}