@shift-defi/strategies 0.1.0 → 0.2.0

package/contracts/aave-v3/AaveV3Supply.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {AaveV3SupplyBase} from "./AaveV3SupplyBase.sol";
+
+contract AaveV3Supply is AaveV3SupplyBase {
+    using SafeERC20 for IERC20;
+    using Math for uint256;
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the AaveV3Supply strategy contract
+    /// @dev Sets up the Aave pool, reserve asset, and aToken addresses, and configures the strategy states
+    /// @param strategyContainer The address of the strategy container contract
+    /// @param _pool The address of the Aave V3 Pool contract
+    /// @param _reserveAsset The address of the underlying asset to be supplied to Aave
+    /// @param slippageParams The enter/exit/emergency-exit maximum slippage parameters
+    function initialize(
+        address strategyContainer,
+        address _pool,
+        address _reserveAsset,
+        SlippageParams calldata slippageParams
+    ) external initializer {
+        __AaveV3Supply_init(strategyContainer, _pool, _reserveAsset, slippageParams);
+    }
+
+    function _harvest(bytes32 stateId, address treasury, uint256 feePct) internal override {
+        // Supplied state only: a paused reserve reverts aToken fee transfers, which must not block token-state exits
+        if (stateId != AAVE_RESERVE_SUPPLIED_STATE_ID) {
+            return;
+        }
+
+        AaveHarvestLocalVars memory vars;
+        vars.reserveATokenCached = reserveAToken;
+        vars.currentReserveATokenBalance = IERC20(vars.reserveATokenCached).balanceOf(address(this));
+        vars.lastReserveATokenBalanceCached = lastReserveATokenBalance;
+
+        if (vars.currentReserveATokenBalance <= vars.lastReserveATokenBalanceCached) {
+            return;
+        }
+
+        vars.income = vars.currentReserveATokenBalance - vars.lastReserveATokenBalanceCached;
+        vars.fee = vars.income.mulDiv(feePct, MAX_BPS);
+
+        if (vars.fee > 0) {
+            IERC20(vars.reserveATokenCached).safeTransfer(treasury, vars.fee);
+        }
+
+        lastReserveATokenBalance = IERC20(vars.reserveATokenCached).balanceOf(address(this));
+    }
+}

package/contracts/aave-v3/AaveV3SupplyBase.sol

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {StrategyTemplate} from "@shift-defi/core/StrategyTemplate.sol";
+import {IStrategyTemplate} from "@shift-defi/core/interfaces/IStrategyTemplate.sol";
+import {Errors} from "@shift-defi/core/libraries/Errors.sol";
+
+import {IPool} from "../dependencies/aave-v3/IPool.sol";
+import {IAaveV3Supply} from "../interfaces/IAaveV3Supply.sol";
+
+/// @notice Shared Aave V3 supply logic. Concrete strategies only need to implement `_harvest` -
+///         everything else (state machine, enter/exit, NAV) is identical regardless of how rewards
+///         are harvested.
+abstract contract AaveV3SupplyBase is StrategyTemplate, IAaveV3Supply {
+    using SafeERC20 for IERC20;
+    using Math for uint256;
+
+    /// @notice The Aave V3 Pool contract address
+    address public pool;
+
+    /// @notice The underlying asset address that is being supplied to Aave
+    address public reserveAsset;
+
+    /// @notice The aToken address corresponding to the reserve asset
+    address public reserveAToken;
+
+    /// @notice The last recorded balance of aTokens, used for harvest calculations
+    uint256 public lastReserveATokenBalance;
+
+    /// @notice State ID for the underlying asset state (holding the asset directly)
+    bytes32 internal constant UNDERLYING_ASSET_STATE_ID = keccak256("UNDERLYING_ASSET_STATE_ID");
+
+    /// @notice State ID for the Aave reserve supplied state (asset supplied to Aave)
+    bytes32 internal constant AAVE_RESERVE_SUPPLIED_STATE_ID = keccak256("AAVE_RESERVE_SUPPLIED_STATE_ID");
+
+    /// @notice Aave's ray precision, the unit of the reserve liquidity index
+    uint256 internal constant RAY = 1e27;
+
+    /// @dev Shared initializer logic, exposed so subclasses can compose it with their own additional setup
+    ///      inside a single `initializer`-guarded call.
+    function __AaveV3Supply_init(
+        address strategyContainer,
+        address _pool,
+        address _reserveAsset,
+        SlippageParams calldata slippageParams
+    ) internal onlyInitializing {
+        __StrategyTemplate_init(
+            strategyContainer,
+            slippageParams.enterMaxSlippage,
+            slippageParams.exitMaxSlippage,
+            slippageParams.emergencyExitMaxSlippage
+        );
+
+        require(_pool != address(0), Errors.ZeroAddress());
+        pool = _pool;
+
+        require(_reserveAsset != address(0), Errors.ZeroAddress());
+        reserveAsset = _reserveAsset;
+
+        reserveAToken = IPool(_pool).getReserveAToken(_reserveAsset);
+
+        _setState(UNDERLYING_ASSET_STATE_ID, false, false, true, 0);
+        _setState(AAVE_RESERVE_SUPPLIED_STATE_ID, true, true, false, 1);
+    }
+
+    // -------- Strategy Template Implementations --------
+
+    /// @inheritdoc IStrategyTemplate
+    function stateNav(bytes32 stateId) public view override returns (uint256) {
+        if (stateId == UNDERLYING_ASSET_STATE_ID) {
+            return underlyingAssetNav();
+        } else if (stateId == AAVE_RESERVE_SUPPLIED_STATE_ID) {
+            return aaveReserveSuppliedNav();
+        } else if (stateId == NO_ALLOCATION_STATE_ID) {
+            return 0;
+        }
+        revert StateNotFound(stateId);
+    }
+
+    /// @notice Calculates the NAV for the underlying asset state
+    /// @dev Returns the value of underlying assets held by the contract in notion
+    /// @return The NAV of underlying assets in notion
+    function underlyingAssetNav() public view returns (uint256) {
+        address reserveAssetCached = reserveAsset;
+        return getTokenAmountInNotion(reserveAssetCached, IERC20(reserveAssetCached).balanceOf(address(this)));
+    }
+
+    /// @notice Calculates the NAV for the Aave reserve supplied state
+    /// @dev Returns the value of aTokens held by the contract in notion
+    /// @return The NAV of aTokens in notion
+    function aaveReserveSuppliedNav() public view returns (uint256) {
+        return getTokenAmountInNotion(reserveAsset, IERC20(reserveAToken).balanceOf(address(this)));
+    }
+
+    function _enterTarget() internal override {
+        _enterAaveReserveSupplied();
+    }
+
+    function _enterState(bytes32 stateId) internal override {
+        if (stateId == AAVE_RESERVE_SUPPLIED_STATE_ID) {
+            _enterAaveReserveSupplied();
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _enterAaveReserveSupplied() internal {
+        address reserveAssetCached = reserveAsset;
+        uint256 underlyingAssetBalance = IERC20(reserveAssetCached).balanceOf(address(this));
+
+        if (underlyingAssetBalance == 0) {
+            return;
+        }
+
+        address poolCached = pool;
+
+        // Aave reverts a supply that mints zero scaled aTokens (amount * RAY / liquidityIndex rounds down to 0).
+        // Leave such dust idle for a later supply so it can't be used to make harvest revert.
+        if (underlyingAssetBalance.mulDiv(RAY, IPool(poolCached).getReserveNormalizedIncome(reserveAssetCached)) == 0) {
+            return;
+        }
+
+        IERC20(reserveAssetCached).safeIncreaseAllowance(poolCached, underlyingAssetBalance);
+        IPool(poolCached).supply(reserveAssetCached, underlyingAssetBalance, address(this), 0);
+        lastReserveATokenBalance = IERC20(reserveAToken).balanceOf(address(this));
+    }
+
+    function _exitTarget(uint256 share) internal override {
+        _exitAaveReserveSupplied(share);
+    }
+
+    function _exitFromState(bytes32 stateId, uint256 share) internal override {
+        if (stateId == AAVE_RESERVE_SUPPLIED_STATE_ID) {
+            _exitAaveReserveSupplied(share);
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _exitAaveReserveSupplied(uint256 share) internal {
+        uint256 allocatedAmount = IERC20(reserveAToken).balanceOf(address(this));
+        require(allocatedAmount > 0, NoReserveAllocation());
+
+        uint256 amountToWithdraw = allocatedAmount.mulDiv(share, MAX_BPS);
+        _exitAaveReserveSuppliedFlat(amountToWithdraw);
+    }
+
+    function _emergencyExit(bytes32 toStateId, uint256 share) internal override {
+        if (toStateId == UNDERLYING_ASSET_STATE_ID) {
+            _exitAaveReserveSupplied(share);
+        } else {
+            revert StateNotFound(toStateId);
+        }
+    }
+
+    function _exitAaveReserveSuppliedFlat(uint256 amount) internal returns (uint256) {
+        require(amount > 0, WithdrawAmountTooSmall());
+        address reserveAssetCached = reserveAsset;
+
+        uint256 reserveBalanceBefore = IERC20(reserveAssetCached).balanceOf(address(this));
+        uint256 withdrawnAmount = IPool(pool).withdraw(reserveAssetCached, amount, address(this));
+
+        require(
+            IERC20(reserveAssetCached).balanceOf(address(this)) >= reserveBalanceBefore + withdrawnAmount,
+            WithdrawAmountMismatch()
+        );
+
+        lastReserveATokenBalance = IERC20(reserveAToken).balanceOf(address(this));
+        return withdrawnAmount;
+    }
+
+    uint256[50] private __gap;
+}

package/contracts/aave-v3/AaveV3SupplyWithMerkle.sol

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {IStrategyContainer} from "@shift-defi/core/interfaces/IStrategyContainer.sol";
+import {Errors} from "@shift-defi/core/libraries/Errors.sol";
+
+import {AaveV3SupplyBase} from "./AaveV3SupplyBase.sol";
+import {IAngleMerkleDistributor} from "../dependencies/angle/IAngleMerkleDistributor.sol";
+import {IAaveV3SupplyWithMerkle} from "../interfaces/IAaveV3SupplyWithMerkle.sol";
+
+contract AaveV3SupplyWithMerkle is AccessControlUpgradeable, AaveV3SupplyBase, IAaveV3SupplyWithMerkle {
+    using SafeERC20 for IERC20;
+    using Math for uint256;
+
+    /// @notice Role for the Merkle claimer
+    bytes32 private constant MERKLE_CLAIMER_ROLE = keccak256("MERKLE_CLAIMER_ROLE");
+
+    /// @notice The address of the Merkle distributor contract
+    address public merkleDistributor;
+
+    /// @notice The addresses of the reward tokens reinvested during automatic harvest
+    address[] internal rewardTokens;
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the AaveV3SupplyWithMerkle strategy contract
+    /// @dev Composes `AaveV3SupplyBase`'s initializer with the Merkle claim setup inside one
+    ///      `initializer`-guarded call
+    /// @param strategyContainer The address of the strategy container contract
+    /// @param defaultAdmin The address of the default admin
+    /// @param merkleClaimer The address of the Merkle claimer
+    /// @param _pool The address of the Aave V3 Pool contract
+    /// @param _reserveAsset The address of the underlying asset to be supplied to Aave
+    /// @param _merkleDistributor The address of the Merkle distributor
+    /// @param _rewardTokens The addresses of the reward tokens
+    /// @param slippageParams The enter/exit/emergency-exit maximum slippage parameters
+    function initialize(
+        address strategyContainer,
+        address defaultAdmin,
+        address merkleClaimer,
+        address _pool,
+        address _reserveAsset,
+        address _merkleDistributor,
+        address[] calldata _rewardTokens,
+        SlippageParams calldata slippageParams
+    ) external initializer {
+        __AccessControl_init();
+        __AaveV3Supply_init(strategyContainer, _pool, _reserveAsset, slippageParams);
+
+        require(defaultAdmin != address(0), Errors.ZeroAddress());
+        _grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);
+        require(merkleClaimer != address(0), Errors.ZeroAddress());
+        _grantRole(MERKLE_CLAIMER_ROLE, merkleClaimer);
+
+        require(_merkleDistributor != address(0), Errors.ZeroAddress());
+        merkleDistributor = _merkleDistributor;
+
+        _setRewardTokens(_rewardTokens);
+    }
+
+    /// @inheritdoc IAaveV3SupplyWithMerkle
+    function getRewardTokens() external view override returns (address[] memory) {
+        return rewardTokens;
+    }
+
+    /// @inheritdoc IAaveV3SupplyWithMerkle
+    function setRewardTokens(address[] memory _rewardTokens) external onlyStrategyContainerOrHarvestManager {
+        _setRewardTokens(_rewardTokens);
+    }
+
+    function _setRewardTokens(address[] memory _rewardTokens) private {
+        uint256 rewardTokensLength = _rewardTokens.length;
+        address reserveAssetCached = reserveAsset;
+        address reserveATokenCached = reserveAToken;
+
+        for (uint256 i = 0; i < rewardTokensLength; ++i) {
+            require(_rewardTokens[i] != address(0), Errors.ZeroAddress());
+            require(_rewardTokens[i] != reserveAssetCached, RewardTokenMatchesReserveAsset());
+            require(_rewardTokens[i] != reserveATokenCached, RewardTokenMatchesReserveAToken());
+        }
+
+        rewardTokens = _rewardTokens;
+        emit RewardTokensUpdated(_rewardTokens);
+    }
+
+    function _harvest(bytes32 stateId, address treasury, uint256 feePct) internal override {
+        // Supplied state only: a paused reserve reverts aToken fee transfers, which must not block token-state exits
+        if (stateId != AAVE_RESERVE_SUPPLIED_STATE_ID) {
+            return;
+        }
+
+        AutomaticHarvestLocalVars memory vars;
+        vars.reserveATokenCached = reserveAToken;
+        vars.reserveAssetCached = reserveAsset;
+        vars.balanceBeforeReinvest = lastReserveATokenBalance;
+        vars.currentBalance = IERC20(vars.reserveATokenCached).balanceOf(address(this));
+
+        if (vars.currentBalance > vars.balanceBeforeReinvest) {
+            vars.feeToTreasury = (vars.currentBalance - vars.balanceBeforeReinvest).mulDiv(feePct, MAX_BPS);
+        }
+
+        vars.rewardTokensLength = rewardTokens.length;
+        for (uint256 i = 0; i < vars.rewardTokensLength; ++i) {
+            _swapToInputTokens(rewardTokens[i], vars.reserveAssetCached, 0, false);
+        }
+        vars.aTokenBalanceBefore = IERC20(vars.reserveATokenCached).balanceOf(address(this));
+        _enterAaveReserveSupplied();
+        vars.aTokenDelta = IERC20(vars.reserveATokenCached).balanceOf(address(this)) - vars.aTokenBalanceBefore;
+        if (vars.aTokenDelta > 0) {
+            vars.feeFromReinvest = vars.aTokenDelta.mulDiv(feePct, MAX_BPS);
+            if (vars.feeFromReinvest > 0) {
+                vars.feeToTreasury += vars.feeFromReinvest;
+            }
+        }
+
+        if (vars.feeToTreasury > 0) {
+            IERC20(vars.reserveATokenCached).safeTransfer(treasury, vars.feeToTreasury);
+        }
+
+        vars.currentBalance = IERC20(vars.reserveATokenCached).balanceOf(address(this));
+
+        lastReserveATokenBalance = Math.max(vars.currentBalance, vars.balanceBeforeReinvest);
+    }
+
+    /// @inheritdoc IAaveV3SupplyWithMerkle
+    function manualClaim(
+        address[] calldata tokens,
+        uint256[] calldata amounts,
+        bytes32[][] calldata proofs
+    ) external nonReentrant onlyRole(MERKLE_CLAIMER_ROLE) {
+        require(!isNavResolutionMode(), NavResolutionModeActivated());
+
+        ManualClaimLocalVars memory vars;
+        vars.reserveATokenCached = reserveAToken;
+        vars.reserveAssetCached = reserveAsset;
+        vars.strategyContainerCached = _strategyContainer;
+
+        vars.treasury = IStrategyContainer(vars.strategyContainerCached).treasury();
+        require(vars.treasury != address(0), Errors.ZeroAddress());
+        vars.feePct = IStrategyContainer(vars.strategyContainerCached).feePct();
+        vars.lastBalanceCached = lastReserveATokenBalance;
+
+        vars.users = new address[](1);
+        vars.users[0] = address(this);
+        IAngleMerkleDistributor(merkleDistributor).claim(vars.users, tokens, amounts, proofs);
+
+        if (currentStateId() == AAVE_RESERVE_SUPPLIED_STATE_ID) {
+            uint256 tokensLength = tokens.length;
+            for (uint256 i = 0; i < tokensLength; ++i) {
+                if (tokens[i] == vars.reserveAssetCached) {
+                    _enterAaveReserveSupplied();
+                    break;
+                }
+            }
+
+            vars.currentBalance = IERC20(vars.reserveATokenCached).balanceOf(address(this));
+            if (vars.currentBalance > vars.lastBalanceCached) {
+                vars.fee = (vars.currentBalance - vars.lastBalanceCached).mulDiv(vars.feePct, MAX_BPS);
+                if (vars.fee > 0) {
+                    IERC20(vars.reserveATokenCached).safeTransfer(vars.treasury, vars.fee);
+                }
+            }
+        }
+
+        lastReserveATokenBalance = IERC20(vars.reserveATokenCached).balanceOf(address(this));
+    }
+}

package/contracts/interfaces/IAaveV3Supply.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IAaveV3Supply {
+    // ---- Structs ----
+
+    struct SlippageParams {
+        uint256 enterMaxSlippage;
+        uint256 exitMaxSlippage;
+        uint256 emergencyExitMaxSlippage;
+    }
+
+    struct AaveHarvestLocalVars {
+        address reserveATokenCached;
+        uint256 lastReserveATokenBalanceCached;
+        uint256 currentReserveATokenBalance;
+        uint256 income;
+        uint256 fee;
+    }
+
+    // ---- Errors ----
+
+    error NoReserveAllocation();
+    error WithdrawAmountTooSmall();
+    error WithdrawAmountMismatch();
+}

package/contracts/interfaces/IAaveV3SupplyWithMerkle.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IAaveV3SupplyWithMerkle {
+    // ---- Structs ----
+
+    struct AutomaticHarvestLocalVars {
+        address reserveAssetCached;
+        address reserveATokenCached;
+        uint256 rewardTokensLength;
+        uint256 aTokenBalanceBefore;
+        uint256 aTokenDelta;
+        uint256 balanceBeforeReinvest;
+        uint256 currentBalance;
+        uint256 feeToTreasury;
+        uint256 feeFromReinvest;
+    }
+
+    struct ManualClaimLocalVars {
+        address reserveATokenCached;
+        address strategyContainerCached;
+        address reserveAssetCached;
+        address treasury;
+        uint256 feePct;
+        uint256 lastBalanceCached;
+        uint256 currentBalance;
+        uint256 fee;
+        address[] users;
+    }
+
+    // ---- Events ----
+
+    event RewardTokensUpdated(address[] rewardTokens);
+
+    // ---- Errors ----
+
+    error RewardTokenMatchesReserveAsset();
+    error RewardTokenMatchesReserveAToken();
+
+    // ---- Functions ----
+
+    /// @notice Returns the reward tokens
+    /// @return The addresses of the reward tokens
+    function getRewardTokens() external view returns (address[] memory);
+
+    /// @notice Sets the reward tokens. Only callable by role HARVEST_MANAGER_ROLE
+    /// @param _rewardTokens The addresses of the reward tokens
+    function setRewardTokens(address[] memory _rewardTokens) external;
+
+    /// @notice Manually claims the rewards. Only callable by role MERKLE_CLAIMER_ROLE
+    /// @dev Only the reserve asset is reinvested instantly, and only while currently supplied to Aave;
+    ///      any other claimed reward (e.g. WMON), and any claim made while not supplied, is left on the
+    ///      contract and reinvested by the next automatic harvest instead
+    /// @param tokens The addresses of the tokens
+    /// @param amounts The amounts of the tokens
+    /// @param proofs The proofs of the merkle proofs
+    function manualClaim(address[] calldata tokens, uint256[] calldata amounts, bytes32[][] calldata proofs) external;
+}

package/contracts/interfaces/IMorphoVault.sol

@@ -15,6 +15,7 @@ interface IMorphoVault {
         uint256 reinvestLpDelta;
         uint256 feeFromReinvest;
         uint256 currentAssetsValue;
+        uint256 lastAssetsValueCached;
     }
 
     struct ManualClaimLocalVars {
@@ -32,6 +33,7 @@ interface IMorphoVault {
         uint256 reinvestLpDelta;
         uint256 feeFromReinvest;
         uint256 currentAssetsValue;
+        uint256 lastAssetsValueCached;
     }
 
     // ---- Events ----

package/contracts/morpho/MorphoVault.sol

@@ -215,12 +215,11 @@ contract MorphoVault is AccessControlUpgradeable, StrategyTemplate, IMorphoVault
         }
     }
 
-    function _calculateAccruedAssetsValue() private view returns (uint256) {
+    function _calculateAccruedAssetsValue(uint256 lastAssetsValueCached) private view returns (uint256) {
         address morphoVaultCached = morphoVault;
         uint256 currentAssetsValue = IERC4626(morphoVaultCached).convertToAssets(
             IERC4626(morphoVaultCached).balanceOf(address(this))
         );
-        uint256 lastAssetsValueCached = lastAssetsValue;
 
         if (currentAssetsValue > lastAssetsValueCached) {
             return currentAssetsValue - lastAssetsValueCached;
@@ -236,7 +235,9 @@ contract MorphoVault is AccessControlUpgradeable, StrategyTemplate, IMorphoVault
         vars.underlyingAssetCached = underlyingAsset;
         vars.rewardTokensLength = rewardTokens.length;
 
-        vars.accruedAssetsValue = _calculateAccruedAssetsValue();
+        // Cached before reinvesting: `_enterMorphoVault` overwrites `lastAssetsValue` with the pre-fee value
+        vars.lastAssetsValueCached = lastAssetsValue;
+        vars.accruedAssetsValue = _calculateAccruedAssetsValue(vars.lastAssetsValueCached);
 
         if (vars.accruedAssetsValue > 0) {
             vars.accruedVaultTokens = IERC4626(vars.morphoVaultCached).convertToShares(vars.accruedAssetsValue);
@@ -268,9 +269,7 @@ contract MorphoVault is AccessControlUpgradeable, StrategyTemplate, IMorphoVault
             IERC4626(vars.morphoVaultCached).balanceOf(address(this))
         );
 
-        if (vars.currentAssetsValue > lastAssetsValue) {
-            lastAssetsValue = vars.currentAssetsValue;
-        }
+        lastAssetsValue = Math.max(vars.currentAssetsValue, vars.lastAssetsValueCached);
     }
 
     /// @inheritdoc IMorphoVault
@@ -294,7 +293,9 @@ contract MorphoVault is AccessControlUpgradeable, StrategyTemplate, IMorphoVault
 
         vars.feePct = IStrategyContainer(vars.strategyContainerCached).feePct();
 
-        vars.accruedAssetsValue = _calculateAccruedAssetsValue();
+        // Cached before reinvesting: `_enterMorphoVault` overwrites `lastAssetsValue` with the pre-fee value
+        vars.lastAssetsValueCached = lastAssetsValue;
+        vars.accruedAssetsValue = _calculateAccruedAssetsValue(vars.lastAssetsValueCached);
         if (vars.accruedAssetsValue > 0) {
             vars.accruedVaultTokens = IERC4626(vars.morphoVaultCached).convertToShares(vars.accruedAssetsValue);
             vars.vaultTokensToTreasury = vars.accruedVaultTokens.mulDiv(vars.feePct, MAX_BPS);
@@ -333,8 +334,6 @@ contract MorphoVault is AccessControlUpgradeable, StrategyTemplate, IMorphoVault
             IERC4626(vars.morphoVaultCached).balanceOf(address(this))
         );
 
-        if (vars.currentAssetsValue > lastAssetsValue) {
-            lastAssetsValue = vars.currentAssetsValue;
-        }
+        lastAssetsValue = Math.max(vars.currentAssetsValue, vars.lastAssetsValueCached);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shift-defi/strategies",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Strategy smart contracts for Shift DeFi Platform",
   "author": "ShiftDeFi",
   "license": "MIT",
@@ -10,13 +10,16 @@
   },
   "homepage": "https://shiftdefi.com/",
   "files": [
-    "contracts/**/*.sol"
+    "contracts/**/*.sol",
+    "!contracts/dependencies/safe"
   ],
   "scripts": {
-    "prepare": "husky"
+    "prepare": "husky",
+    "claim": "set -a; [ -f tools/merkl-claim.env ] && . ./tools/merkl-claim.env; set +a; node tools/merkl-claim.mjs",
+    "claim:propose": "npm run claim -- --propose"
   },
   "dependencies": {
-    "@shift-defi/core": "^0.7.0"
+    "@shift-defi/core": "^0.7.1"
   },
   "devDependencies": {
     "@commitlint/cli": "^20.2.0",
@@ -30,7 +33,7 @@
     "*.sol": [
       "prettier --write --plugin=prettier-plugin-solidity"
     ],
-    "*.{ts,json,md,yml,yaml}": [
+    "*.{ts,mjs,json,md,yml,yaml}": [
       "prettier --write"
     ]
   }