@shift-defi/strategies 0.1.0

package/contracts/interfaces/ICompoundV3Supply.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface ICompoundV3Supply {
+    struct InternalHarvestLocalVars {
+        address depositToken;
+        address cToken;
+        uint256 cTokenDecimalsFactor;
+        uint256 dTokenDecimalsFactor;
+        uint256 cTokenIncome;
+        uint256 cTokenIncomeInAsset;
+        uint256 beforeBalance;
+        uint256 compRewardsInAsset;
+        uint256 treasuryFee;
+        uint256 missingFeeInAsset;
+        uint256 cTokensToWithdraw;
+        uint256 currentCTokenBalance;
+        uint256 incomeShare;
+    }
+
+    struct InternalEnterLocalVars {
+        uint256 balance;
+        address depositToken;
+        address cToken;
+    }
+
+    struct InternalExitLocalVars {
+        uint256 balance;
+        uint256 liquidity;
+        address cToken;
+    }
+}

package/contracts/interfaces/ICurveGauge.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface ICurveGauge {
+    struct AutomaticHarvestLocalVars {
+        address gaugeCached;
+        address lpTokenCached;
+        address asset0Cached;
+        address asset1Cached;
+        uint256 lastStoredGaugeBalance;
+        uint256 lastStoredVirtualPrice;
+        uint256 currentGaugeBalance;
+        uint256 currentVirtualPrice;
+        uint256 accruedLpValue;
+        uint256 gaugeTokensToTreasury;
+        uint256 asset0BalanceBefore;
+        uint256 asset1BalanceBefore;
+        uint256 asset0Rewards;
+        uint256 asset1Rewards;
+        uint256 reinvestGaugeDelta;
+        uint256 feeFromReinvest;
+    }
+
+    function gauge() external view returns (address);
+
+    function lpToken() external view returns (address);
+
+    function underlyingAsset0() external view returns (address);
+
+    function underlyingAsset1() external view returns (address);
+
+    function lastStoredVirtualPrice() external view returns (uint256);
+
+    function lastStoredGaugeBalance() external view returns (uint256);
+}

package/contracts/interfaces/IFluidSupply.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IFluidSupply {
+    struct AutomaticHarvestLocalVars {
+        address fTokenCached;
+        address merkleRewardToken;
+        uint256 accruedAssetsValue;
+        uint256 accruedFTokenAmount;
+        uint256 fTokensToTreasury;
+        uint256 fTokensAmountBefore;
+        uint256 reinvestFTokenDelta;
+        uint256 feeFromReinvest;
+    }
+
+    struct ClaimParams {
+        uint256 cumulativeAmount;
+        uint256 cycle;
+        bytes32[] merkleProof;
+        bytes metadata;
+    }
+
+    /// @notice Claims rewards from Fluid Merkle distributor
+    /// @param claimParams The parameters for the claim operation
+    function manualClaim(ClaimParams calldata claimParams) external;
+}

package/contracts/interfaces/IMorphoVault.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IMorphoVault {
+    // ---- Structs ----
+
+    struct AutomaticHarvestLocalVars {
+        address morphoVaultCached;
+        address underlyingAssetCached;
+        uint256 rewardTokensLength;
+        uint256 accruedAssetsValue;
+        uint256 accruedVaultTokens;
+        uint256 vaultTokensToTreasury;
+        uint256 lpAmountBefore;
+        uint256 reinvestLpDelta;
+        uint256 feeFromReinvest;
+        uint256 currentAssetsValue;
+    }
+
+    struct ManualClaimLocalVars {
+        address morphoVaultCached;
+        address underlyingAssetCached;
+        address strategyContainerCached;
+        uint256 rewardTokensLength;
+        address treasury;
+        uint256 feePct;
+        uint256 accruedAssetsValue;
+        uint256 accruedVaultTokens;
+        uint256 vaultTokensToTreasury;
+        uint256 lpAmountBefore;
+        address[] users;
+        uint256 reinvestLpDelta;
+        uint256 feeFromReinvest;
+        uint256 currentAssetsValue;
+    }
+
+    // ---- Events ----
+
+    event RewardTokensUpdated(address[] rewardTokens);
+
+    // ---- Errors ----
+
+    error RewardTokenMatchesUnderlyingAsset();
+    error RewardTokenMatchesMorphoVault();
+
+    // ---- 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 callabe 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 Underlying asset claimed via manual claim is instantly reinvested,
+    ///      other reward tokens are reinvested during standard harvest
+    /// @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/morpho/MorphoVault.sol

@@ -0,0 +1,340 @@
+// 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 {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.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 {StrategyTemplate} from "@shift-defi/core/StrategyTemplate.sol";
+import {Errors} from "@shift-defi/core/libraries/Errors.sol";
+
+import {IMorphoVault} from "../interfaces/IMorphoVault.sol";
+
+import {IAngleMerkleDistributor} from "../dependencies/angle/IAngleMerkleDistributor.sol";
+
+contract MorphoVault is AccessControlUpgradeable, StrategyTemplate, IMorphoVault {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+
+    /// @notice State ID for the Morpho vault state (morpho vault)
+    bytes32 internal constant MORPHO_VAULT_STATE_ID = keccak256("MORPHO_VAULT_STATE_ID");
+
+    /// @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 Role for the Merkle claimer
+    bytes32 private constant MERKLE_CLAIMER_ROLE = keccak256("MERKLE_CLAIMER_ROLE");
+
+    /// @notice The Morpho vault address
+    address public morphoVault;
+
+    /// @notice The underlying asset address
+    address public underlyingAsset;
+
+    /// @notice The address of the Morpho Merkle distributor contract
+    address public merkleDistributor;
+
+    /// @notice The addresses of the reward tokens
+    address[] internal rewardTokens;
+
+    /// @notice The last recorded value of vault token amount * share price
+    uint256 public lastAssetsValue;
+
+    struct SlippageParams {
+        uint256 enterMaxSlippage;
+        uint256 exitMaxSlippage;
+        uint256 emergencyExitMaxSlippage;
+    }
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the MorphoVaultStrategy contract
+    /// @dev Sets up the Morpho vault, underlying asset, reward tokens, and configures the strategy states
+    /// @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 _morphoVault The address of the Morpho vault
+    /// @param _merkleDistributor The address of the Merkle distributor
+    /// @param _rewardTokens The addresses of the reward tokens
+    /// @param slippageParams The slippage parameters
+
+    function initialize(
+        address strategyContainer,
+        address defaultAdmin,
+        address merkleClaimer,
+        address _morphoVault,
+        address _merkleDistributor,
+        address[] calldata _rewardTokens,
+        SlippageParams calldata slippageParams
+    ) external initializer {
+        __AccessControl_init();
+
+        __StrategyTemplate_init(
+            strategyContainer,
+            slippageParams.enterMaxSlippage,
+            slippageParams.exitMaxSlippage,
+            slippageParams.emergencyExitMaxSlippage
+        );
+
+        require(defaultAdmin != address(0), Errors.ZeroAddress());
+        _grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);
+        require(merkleClaimer != address(0), Errors.ZeroAddress());
+        _grantRole(MERKLE_CLAIMER_ROLE, merkleClaimer);
+
+        require(_morphoVault != address(0), Errors.ZeroAddress());
+        morphoVault = _morphoVault;
+        underlyingAsset = IERC4626(morphoVault).asset();
+
+        require(_merkleDistributor != address(0), Errors.ZeroAddress());
+        merkleDistributor = _merkleDistributor;
+
+        _setRewardTokens(_rewardTokens);
+
+        _setState(UNDERLYING_ASSET_STATE_ID, false, false, true, 0);
+        _setState(MORPHO_VAULT_STATE_ID, true, true, false, 1);
+    }
+
+    /// @inheritdoc IMorphoVault
+    function getRewardTokens() external view override returns (address[] memory) {
+        return rewardTokens;
+    }
+
+    /// @inheritdoc IMorphoVault
+    function setRewardTokens(address[] memory _rewardTokens) external onlyStrategyContainerOrHarvestManager {
+        _setRewardTokens(_rewardTokens);
+    }
+
+    function _setRewardTokens(address[] memory _rewardTokens) private {
+        uint256 rewardTokensLength = _rewardTokens.length;
+        address underlyingAssetCached = underlyingAsset;
+        address morphoVaultCached = morphoVault;
+
+        for (uint256 i = 0; i < rewardTokensLength; ++i) {
+            require(_rewardTokens[i] != address(0), Errors.ZeroAddress());
+            require(_rewardTokens[i] != underlyingAssetCached, RewardTokenMatchesUnderlyingAsset());
+            require(_rewardTokens[i] != morphoVaultCached, RewardTokenMatchesMorphoVault());
+        }
+
+        rewardTokens = _rewardTokens;
+        emit RewardTokensUpdated(_rewardTokens);
+    }
+
+    function stateNav(bytes32 stateId) public view override returns (uint256) {
+        if (stateId == UNDERLYING_ASSET_STATE_ID) {
+            return _underlyingAssetNav();
+        } else if (stateId == MORPHO_VAULT_STATE_ID) {
+            return _morphoVaultNav();
+        } else if (stateId == NO_ALLOCATION_STATE_ID) {
+            return 0;
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _underlyingAssetNav() private view returns (uint256) {
+        address underlyingAssetCached = underlyingAsset;
+        return getTokenAmountInNotion(underlyingAssetCached, IERC20(underlyingAssetCached).balanceOf(address(this)));
+    }
+
+    function _morphoVaultNav() private view returns (uint256) {
+        address morphoVaultCached = morphoVault;
+        uint256 lpAmount = IERC4626(morphoVaultCached).balanceOf(address(this));
+        uint256 underlyingAssetAmount = IERC4626(morphoVaultCached).convertToAssets(lpAmount);
+        return getTokenAmountInNotion(underlyingAsset, underlyingAssetAmount);
+    }
+
+    function _enterTarget() internal override {
+        _enterMorphoVault();
+    }
+
+    function _enterState(bytes32 stateId) internal override {
+        if (stateId == MORPHO_VAULT_STATE_ID) {
+            _enterMorphoVault();
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _enterMorphoVault() private {
+        address underlyingAssetCached = underlyingAsset;
+        address morphoVaultCached = morphoVault;
+
+        uint256 enterAmount = IERC20(underlyingAssetCached).balanceOf(address(this));
+
+        if (enterAmount == 0) {
+            return;
+        }
+
+        IERC20(underlyingAssetCached).safeIncreaseAllowance(morphoVaultCached, enterAmount);
+        IERC4626(morphoVaultCached).deposit(enterAmount, address(this));
+
+        lastAssetsValue = IERC4626(morphoVaultCached).convertToAssets(
+            IERC4626(morphoVaultCached).balanceOf(address(this))
+        );
+    }
+
+    function _exitTarget(uint256 share) internal override {
+        _exitMorphoVault(share);
+    }
+
+    function _exitFromState(bytes32 stateId, uint256 share) internal override {
+        if (stateId == MORPHO_VAULT_STATE_ID) {
+            _exitMorphoVault(share);
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _exitMorphoVault(uint256 share) private {
+        address morphoVaultCached = morphoVault;
+
+        uint256 lpAmount = IERC4626(morphoVaultCached).balanceOf(address(this));
+        uint256 lpToWithdraw = lpAmount.mulDiv(share, MAX_BPS);
+
+        if (lpToWithdraw == 0) {
+            return;
+        }
+
+        IERC4626(morphoVaultCached).redeem(lpToWithdraw, address(this), address(this));
+
+        lastAssetsValue = IERC4626(morphoVaultCached).convertToAssets(
+            IERC4626(morphoVaultCached).balanceOf(address(this))
+        );
+    }
+
+    function _emergencyExit(bytes32 toStateId, uint256 share) internal override {
+        if (toStateId == UNDERLYING_ASSET_STATE_ID) {
+            _exitMorphoVault(share);
+        } else {
+            revert StateNotFound(toStateId);
+        }
+    }
+
+    function _calculateAccruedAssetsValue() 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;
+        }
+
+        return 0;
+    }
+
+    function _harvest(bytes32 _stateId, address _treasury, uint256 _feePct) internal override {
+        AutomaticHarvestLocalVars memory vars;
+
+        vars.morphoVaultCached = morphoVault;
+        vars.underlyingAssetCached = underlyingAsset;
+        vars.rewardTokensLength = rewardTokens.length;
+
+        vars.accruedAssetsValue = _calculateAccruedAssetsValue();
+
+        if (vars.accruedAssetsValue > 0) {
+            vars.accruedVaultTokens = IERC4626(vars.morphoVaultCached).convertToShares(vars.accruedAssetsValue);
+            vars.vaultTokensToTreasury = vars.accruedVaultTokens.mulDiv(_feePct, MAX_BPS);
+        }
+
+        if (_stateId == MORPHO_VAULT_STATE_ID) {
+            for (uint256 i = 0; i < vars.rewardTokensLength; i++) {
+                _swapToInputTokens(rewardTokens[i], vars.underlyingAssetCached, 0, false);
+            }
+
+            vars.lpAmountBefore = IERC4626(vars.morphoVaultCached).balanceOf(address(this));
+            _enterMorphoVault();
+            vars.reinvestLpDelta = IERC4626(vars.morphoVaultCached).balanceOf(address(this)) - vars.lpAmountBefore;
+
+            if (vars.reinvestLpDelta > 0) {
+                vars.feeFromReinvest = vars.reinvestLpDelta.mulDiv(_feePct, MAX_BPS);
+                if (vars.feeFromReinvest > 0) {
+                    vars.vaultTokensToTreasury += vars.feeFromReinvest;
+                }
+            }
+        }
+
+        if (vars.vaultTokensToTreasury > 0) {
+            IERC20(vars.morphoVaultCached).safeTransfer(_treasury, vars.vaultTokensToTreasury);
+        }
+
+        vars.currentAssetsValue = IERC4626(vars.morphoVaultCached).convertToAssets(
+            IERC4626(vars.morphoVaultCached).balanceOf(address(this))
+        );
+
+        if (vars.currentAssetsValue > lastAssetsValue) {
+            lastAssetsValue = vars.currentAssetsValue;
+        }
+    }
+
+    /// @inheritdoc IMorphoVault
+    function manualClaim(
+        address[] calldata tokens,
+        uint256[] calldata amounts,
+        bytes32[][] calldata proofs
+    ) external nonReentrant onlyRole(MERKLE_CLAIMER_ROLE) {
+        require(!isNavResolutionMode(), NavResolutionModeActivated());
+
+        ManualClaimLocalVars memory vars;
+
+        vars.morphoVaultCached = morphoVault;
+        vars.underlyingAssetCached = underlyingAsset;
+        vars.strategyContainerCached = _strategyContainer;
+
+        vars.rewardTokensLength = tokens.length;
+
+        vars.treasury = IStrategyContainer(vars.strategyContainerCached).treasury();
+        require(vars.treasury != address(0), Errors.ZeroAddress());
+
+        vars.feePct = IStrategyContainer(vars.strategyContainerCached).feePct();
+
+        vars.accruedAssetsValue = _calculateAccruedAssetsValue();
+        if (vars.accruedAssetsValue > 0) {
+            vars.accruedVaultTokens = IERC4626(vars.morphoVaultCached).convertToShares(vars.accruedAssetsValue);
+            vars.vaultTokensToTreasury = vars.accruedVaultTokens.mulDiv(vars.feePct, MAX_BPS);
+        }
+
+        vars.lpAmountBefore = IERC4626(vars.morphoVaultCached).balanceOf(address(this));
+
+        vars.users = new address[](1);
+        vars.users[0] = address(this);
+
+        IAngleMerkleDistributor(merkleDistributor).claim(vars.users, tokens, amounts, proofs);
+
+        if (currentStateId() == MORPHO_VAULT_STATE_ID) {
+            for (uint256 i = 0; i < vars.rewardTokensLength; i++) {
+                if (tokens[i] == vars.underlyingAssetCached) {
+                    _enterMorphoVault();
+                    break;
+                }
+            }
+
+            vars.reinvestLpDelta = IERC4626(vars.morphoVaultCached).balanceOf(address(this)) - vars.lpAmountBefore;
+
+            if (vars.reinvestLpDelta > 0) {
+                vars.feeFromReinvest = vars.reinvestLpDelta.mulDiv(vars.feePct, MAX_BPS);
+                if (vars.feeFromReinvest > 0) {
+                    vars.vaultTokensToTreasury += vars.feeFromReinvest;
+                }
+            }
+        }
+
+        if (vars.vaultTokensToTreasury > 0) {
+            IERC20(vars.morphoVaultCached).safeTransfer(vars.treasury, vars.vaultTokensToTreasury);
+        }
+
+        vars.currentAssetsValue = IERC4626(vars.morphoVaultCached).convertToAssets(
+            IERC4626(vars.morphoVaultCached).balanceOf(address(this))
+        );
+
+        if (vars.currentAssetsValue > lastAssetsValue) {
+            lastAssetsValue = vars.currentAssetsValue;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@shift-defi/strategies",
+  "version": "0.1.0",
+  "description": "Strategy smart contracts for Shift DeFi Platform",
+  "author": "ShiftDeFi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ShiftDeFi/shift-defi-strategies"
+  },
+  "homepage": "https://shiftdefi.com/",
+  "files": [
+    "contracts/**/*.sol"
+  ],
+  "scripts": {
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@shift-defi/core": "^0.7.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "prettier-plugin-solidity": "^2.2.1"
+  },
+  "lint-staged": {
+    "*.sol": [
+      "prettier --write --plugin=prettier-plugin-solidity"
+    ],
+    "*.{ts,json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  }
+}