@shift-defi/strategies 0.1.0

package/contracts/dependencies/aave-v3/IPoolAddressesProvider.sol

@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title IPoolAddressesProvider
+ * @author Aave
+ * @notice Defines the basic interface for a Pool Addresses Provider.
+ */
+interface IPoolAddressesProvider {
+    /**
+     * @dev Emitted when the market identifier is updated.
+     * @param oldMarketId The old id of the market
+     * @param newMarketId The new id of the market
+     */
+    event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);
+
+    /**
+     * @dev Emitted when the pool is updated.
+     * @param oldAddress The old address of the Pool
+     * @param newAddress The new address of the Pool
+     */
+    event PoolUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the pool configurator is updated.
+     * @param oldAddress The old address of the PoolConfigurator
+     * @param newAddress The new address of the PoolConfigurator
+     */
+    event PoolConfiguratorUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the price oracle is updated.
+     * @param oldAddress The old address of the PriceOracle
+     * @param newAddress The new address of the PriceOracle
+     */
+    event PriceOracleUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the ACL manager is updated.
+     * @param oldAddress The old address of the ACLManager
+     * @param newAddress The new address of the ACLManager
+     */
+    event ACLManagerUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the ACL admin is updated.
+     * @param oldAddress The old address of the ACLAdmin
+     * @param newAddress The new address of the ACLAdmin
+     */
+    event ACLAdminUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the price oracle sentinel is updated.
+     * @param oldAddress The old address of the PriceOracleSentinel
+     * @param newAddress The new address of the PriceOracleSentinel
+     */
+    event PriceOracleSentinelUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the pool data provider is updated.
+     * @param oldAddress The old address of the PoolDataProvider
+     * @param newAddress The new address of the PoolDataProvider
+     */
+    event PoolDataProviderUpdated(address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when a new proxy is created.
+     * @param id The identifier of the proxy
+     * @param proxyAddress The address of the created proxy contract
+     * @param implementationAddress The address of the implementation contract
+     */
+    event ProxyCreated(bytes32 indexed id, address indexed proxyAddress, address indexed implementationAddress);
+
+    /**
+     * @dev Emitted when a new non-proxied contract address is registered.
+     * @param id The identifier of the contract
+     * @param oldAddress The address of the old contract
+     * @param newAddress The address of the new contract
+     */
+    event AddressSet(bytes32 indexed id, address indexed oldAddress, address indexed newAddress);
+
+    /**
+     * @dev Emitted when the implementation of the proxy registered with id is updated
+     * @param id The identifier of the contract
+     * @param proxyAddress The address of the proxy contract
+     * @param oldImplementationAddress The address of the old implementation contract
+     * @param newImplementationAddress The address of the new implementation contract
+     */
+    event AddressSetAsProxy(
+        bytes32 indexed id,
+        address indexed proxyAddress,
+        address oldImplementationAddress,
+        address indexed newImplementationAddress
+    );
+
+    /**
+     * @notice Returns the id of the Aave market to which this contract points to.
+     * @return The market id
+     */
+    function getMarketId() external view returns (string memory);
+
+    /**
+     * @notice Associates an id with a specific PoolAddressesProvider.
+     * @dev This can be used to create an onchain registry of PoolAddressesProviders to
+     * identify and validate multiple Aave markets.
+     * @param newMarketId The market id
+     */
+    function setMarketId(string calldata newMarketId) external;
+
+    /**
+     * @notice Returns an address by its identifier.
+     * @dev The returned address might be an EOA or a contract, potentially proxied
+     * @dev It returns ZERO if there is no registered address with the given id
+     * @param id The id
+     * @return The address of the registered for the specified id
+     */
+    function getAddress(bytes32 id) external view returns (address);
+
+    /**
+     * @notice General function to update the implementation of a proxy registered with
+     * certain `id`. If there is no proxy registered, it will instantiate one and
+     * set as implementation the `newImplementationAddress`.
+     * @dev IMPORTANT Use this function carefully, only for ids that don't have an explicit
+     * setter function, in order to avoid unexpected consequences
+     * @param id The id
+     * @param newImplementationAddress The address of the new implementation
+     */
+    function setAddressAsProxy(bytes32 id, address newImplementationAddress) external;
+
+    /**
+     * @notice Sets an address for an id replacing the address saved in the addresses map.
+     * @dev IMPORTANT Use this function carefully, as it will do a hard replacement
+     * @param id The id
+     * @param newAddress The address to set
+     */
+    function setAddress(bytes32 id, address newAddress) external;
+
+    /**
+     * @notice Returns the address of the Pool proxy.
+     * @return The Pool proxy address
+     */
+    function getPool() external view returns (address);
+
+    /**
+     * @notice Updates the implementation of the Pool, or creates a proxy
+     * setting the new `pool` implementation when the function is called for the first time.
+     * @param newPoolImpl The new Pool implementation
+     */
+    function setPoolImpl(address newPoolImpl) external;
+
+    /**
+     * @notice Returns the address of the PoolConfigurator proxy.
+     * @return The PoolConfigurator proxy address
+     */
+    function getPoolConfigurator() external view returns (address);
+
+    /**
+     * @notice Updates the implementation of the PoolConfigurator, or creates a proxy
+     * setting the new `PoolConfigurator` implementation when the function is called for the first time.
+     * @param newPoolConfiguratorImpl The new PoolConfigurator implementation
+     */
+    function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;
+
+    /**
+     * @notice Returns the address of the price oracle.
+     * @return The address of the PriceOracle
+     */
+    function getPriceOracle() external view returns (address);
+
+    /**
+     * @notice Updates the address of the price oracle.
+     * @param newPriceOracle The address of the new PriceOracle
+     */
+    function setPriceOracle(address newPriceOracle) external;
+
+    /**
+     * @notice Returns the address of the ACL manager.
+     * @return The address of the ACLManager
+     */
+    function getACLManager() external view returns (address);
+
+    /**
+     * @notice Updates the address of the ACL manager.
+     * @param newAclManager The address of the new ACLManager
+     */
+    function setACLManager(address newAclManager) external;
+
+    /**
+     * @notice Returns the address of the ACL admin.
+     * @return The address of the ACL admin
+     */
+    function getACLAdmin() external view returns (address);
+
+    /**
+     * @notice Updates the address of the ACL admin.
+     * @param newAclAdmin The address of the new ACL admin
+     */
+    function setACLAdmin(address newAclAdmin) external;
+
+    /**
+     * @notice Returns the address of the price oracle sentinel.
+     * @return The address of the PriceOracleSentinel
+     */
+    function getPriceOracleSentinel() external view returns (address);
+
+    /**
+     * @notice Updates the address of the price oracle sentinel.
+     * @param newPriceOracleSentinel The address of the new PriceOracleSentinel
+     */
+    function setPriceOracleSentinel(address newPriceOracleSentinel) external;
+
+    /**
+     * @notice Returns the address of the data provider.
+     * @return The address of the DataProvider
+     */
+    function getPoolDataProvider() external view returns (address);
+
+    /**
+     * @notice Updates the address of the data provider.
+     * @param newDataProvider The address of the new DataProvider
+     */
+    function setPoolDataProvider(address newDataProvider) external;
+}

package/contracts/dependencies/aave-v3/IScaledBalanceToken.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title IScaledBalanceToken
+ * @author Aave
+ * @notice Defines the basic interface for a scaled-balance token.
+ */
+interface IScaledBalanceToken {
+    /**
+     * @dev Emitted after the mint action
+     * @param caller The address performing the mint
+     * @param onBehalfOf The address of the user that will receive the minted tokens
+     * @param value The scaled-up amount being minted (based on user entered amount and balance increase from interest)
+     * @param balanceIncrease The increase in scaled-up balance since the last action of 'onBehalfOf'
+     * @param index The next liquidity index of the reserve
+     */
+    event Mint(
+        address indexed caller,
+        address indexed onBehalfOf,
+        uint256 value,
+        uint256 balanceIncrease,
+        uint256 index
+    );
+
+    /**
+     * @dev Emitted after the burn action
+     * @dev If the burn function does not involve a transfer of the underlying asset, the target defaults to zero address
+     * @param from The address from which the tokens will be burned
+     * @param target The address that will receive the underlying, if any
+     * @param value The scaled-up amount being burned (user entered amount - balance increase from interest)
+     * @param balanceIncrease The increase in scaled-up balance since the last action of 'from'
+     * @param index The next liquidity index of the reserve
+     */
+    event Burn(address indexed from, address indexed target, uint256 value, uint256 balanceIncrease, uint256 index);
+
+    /**
+     * @notice Returns the scaled balance of the user.
+     * @dev The scaled balance is the sum of all the updated stored balance divided by the reserve's liquidity index
+     * at the moment of the update
+     * @param user The user whose balance is calculated
+     * @return The scaled balance of the user
+     */
+    function scaledBalanceOf(address user) external view returns (uint256);
+
+    /**
+     * @notice Returns the scaled balance of the user and the scaled total supply.
+     * @param user The address of the user
+     * @return The scaled balance of the user
+     * @return The scaled total supply
+     */
+    function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);
+
+    /**
+     * @notice Returns the scaled total supply of the scaled balance token. Represents sum(debt/index)
+     * @return The scaled total supply
+     */
+    function scaledTotalSupply() external view returns (uint256);
+
+    /**
+     * @notice Returns last index interest was accrued to the user's balance
+     * @param user The address of the user
+     * @return The last index interest was accrued to the user's balance, expressed in ray
+     */
+    function getPreviousIndex(address user) external view returns (uint256);
+}

package/contracts/dependencies/angle/IAngleMerkleDistributor.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IAngleMerkleDistributor {
+    function claim(
+        address[] calldata users,
+        address[] calldata tokens,
+        uint256[] calldata amounts,
+        bytes32[][] calldata proofs
+    ) external;
+}

package/contracts/dependencies/compound-v3/ICompoundV3.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
+
+interface IcASSETv3 is IERC20 {
+    function baseToken() external view returns (address);
+
+    function supply(address, uint) external;
+
+    function withdraw(address, uint) external;
+
+    function accrueAccount(address) external;
+}
+
+interface IcRewards {
+    function claim(address, address, bool) external;
+}

package/contracts/dependencies/curve/ICurveStableSwapNG.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface ICurveStableSwapNG {
+    function coins(uint256 index) external view returns (address);
+
+    function get_balances() external view returns (uint256[] memory);
+
+    function totalSupply() external view returns (uint256);
+
+    function add_liquidity(uint256[] memory, uint256) external;
+
+    function remove_liquidity(uint256, uint256[] memory) external;
+
+    function get_virtual_price() external view returns (uint256);
+}

package/contracts/dependencies/curve/ILiquidityGaugeV6.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface ILiquidityGaugeV6 {
+    function lp_token() external view returns (address);
+
+    function balanceOf(address) external view returns (uint256);
+
+    function deposit(uint256) external;
+
+    function withdraw(uint256) external;
+
+    function claim_rewards() external;
+
+    function reward_count() external view returns (uint256);
+}

package/contracts/dependencies/fluid/IFluidLendingResolver.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IFluidLendingResolver {
+    function computeFToken(address asset, string memory fTokenType) external view returns (address);
+}

package/contracts/dependencies/fluid/IFluidMerkleDistributor.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IFluidMerkleDistributor {
+    /// @notice Claims rewards for a given recipient
+    /// @param recipient_ - address of the recipient
+    /// @param cumulativeAmount_ - cumulative amount of rewards to claim
+    /// @param positionType_ - type of position, 1 for lending, 2 for vaults, 3 for smart lending, etc
+    /// @param positionId_ - id of the position, fToken address for lending and vaultId for vaults
+    /// @param cycle_ - cycle of the rewards
+    /// @param merkleProof_ - merkle proof of the rewards
+    /// @param metadata_ - metadata of the rewards
+    function claim(
+        address recipient_,
+        uint256 cumulativeAmount_,
+        uint8 positionType_,
+        bytes32 positionId_,
+        uint256 cycle_,
+        bytes32[] calldata merkleProof_,
+        bytes calldata metadata_
+    ) external;
+
+    /// @notice Gets the address of the reward token
+    /// @return The address of the reward token
+    function TOKEN() external view returns (address);
+}

package/contracts/dependencies/fluid/IFluidToken.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IFluidToken {
+    function asset() external view returns (address);
+
+    function deposit(uint256 assets_, address receiver_) external returns (uint256 shares);
+
+    function redeem(uint256 shares_, address receiver_, address owner_) external returns (uint256 assets_);
+
+    function convertToAssets(uint256 shares_) external view returns (uint256);
+
+    function convertToShares(uint256 assets_) external view returns (uint256);
+}

package/contracts/fluid/FluidSupply.sol

@@ -0,0 +1,255 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.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 {IFluidSupply} from "../interfaces/IFluidSupply.sol";
+import {IFluidMerkleDistributor} from "../dependencies/fluid/IFluidMerkleDistributor.sol";
+import {IFluidToken} from "../dependencies/fluid/IFluidToken.sol";
+
+contract FluidSupply is AccessControlUpgradeable, IFluidSupply, StrategyTemplate {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+
+    /// @notice State ID for the Fluid supply state (asset supplied to Fluid)
+    bytes32 private constant FLUID_SUPPLY_STATE_ID = keccak256("FLUID_SUPPLY_STATE_ID");
+
+    /// @notice State ID for the token only state (holding the asset directly)
+    bytes32 private 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 Position type for lending positions of Fluid merkle rewards
+    uint8 private constant POSITION_TYPE_LENDING = 1;
+
+    /// @notice The Fluid fToken address
+    address public fToken;
+
+    /// @notice The underlying asset address
+    address public underlyingAsset;
+
+    /// @notice The last recorded value of vault token amount * share price
+    uint256 public lastAssetsValue;
+
+    /// @notice The address of the Fluid Merkle distributor contract
+    address public merkleDistributor;
+
+    /// @notice The address of the Merkle reward token
+    address public merkleRewardToken;
+
+    struct SlippageParams {
+        uint256 enterMaxSlippage;
+        uint256 exitMaxSlippage;
+        uint256 emergencyExitMaxSlippage;
+    }
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the FluidSupply strategy contract
+    /// @dev Sets up the Fluid fToken and asset addresses, 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 _fToken The address of the strategy's fToken
+    /// @param _merkleDistributor The address of the Merkle distributor
+    function initialize(
+        address strategyContainer,
+        address defaultAdmin,
+        address merkleClaimer,
+        address _fToken,
+        address _merkleDistributor,
+        SlippageParams memory 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(_fToken != address(0), Errors.ZeroAddress());
+        fToken = _fToken;
+        underlyingAsset = IFluidToken(_fToken).asset();
+
+        require(_merkleDistributor != address(0), Errors.ZeroAddress());
+        merkleDistributor = _merkleDistributor;
+
+        merkleRewardToken = IFluidMerkleDistributor(_merkleDistributor).TOKEN();
+
+        _setState(UNDERLYING_ASSET_STATE_ID, false, false, true, 0);
+        _setState(FLUID_SUPPLY_STATE_ID, true, true, false, 1);
+    }
+
+    /// @inheritdoc IStrategyTemplate
+    function stateNav(bytes32 stateId) public view override returns (uint256) {
+        if (stateId == FLUID_SUPPLY_STATE_ID) {
+            return fluidNav();
+        } else if (stateId == UNDERLYING_ASSET_STATE_ID) {
+            return underlyingAssetNav();
+        } else if (stateId == NO_ALLOCATION_STATE_ID) {
+            return 0;
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    /// @notice Calculates the NAV for the Fluid supply state
+    /// @dev Returns the value of fTokens held by the contract in notion
+    /// @return The NAV of fluid supply state in notion
+    function fluidNav() public view returns (uint256) {
+        address fTokenCached = fToken;
+        uint256 fTokenBalance = IERC20(fTokenCached).balanceOf(address(this));
+        return getTokenAmountInNotion(underlyingAsset, IFluidToken(fTokenCached).convertToAssets(fTokenBalance));
+    }
+
+    /// @notice Calculates the NAV for the asset state
+    /// @dev Returns the value of assets held by the contract in notion
+    /// @return The NAV of underlying assets state in notion
+    function underlyingAssetNav() public view returns (uint256) {
+        address underlyingAssetCached = underlyingAsset;
+        return getTokenAmountInNotion(underlyingAssetCached, IERC20(underlyingAssetCached).balanceOf(address(this)));
+    }
+
+    /// @inheritdoc IFluidSupply
+    function manualClaim(ClaimParams calldata claimParams) external nonReentrant onlyRole(MERKLE_CLAIMER_ROLE) {
+        IFluidMerkleDistributor(merkleDistributor).claim(
+            address(this),
+            claimParams.cumulativeAmount,
+            POSITION_TYPE_LENDING,
+            bytes32(uint256(uint160(fToken))),
+            claimParams.cycle,
+            claimParams.merkleProof,
+            claimParams.metadata
+        );
+    }
+
+    function _emergencyExit(bytes32 toStateId, uint256 share) internal override {
+        if (toStateId == UNDERLYING_ASSET_STATE_ID) {
+            _exitFluid(share);
+        } else {
+            revert StateNotFound(toStateId);
+        }
+    }
+
+    function _enterState(bytes32 stateId) internal override {
+        if (stateId == FLUID_SUPPLY_STATE_ID) {
+            _enterFluid();
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _exitFromState(bytes32 stateId, uint256 share) internal virtual override {
+        if (stateId == FLUID_SUPPLY_STATE_ID) {
+            _exitFluid(share);
+        } else {
+            revert StateNotFound(stateId);
+        }
+    }
+
+    function _enterTarget() internal override {
+        _enterFluid();
+    }
+
+    function _exitTarget(uint256 share) internal override {
+        _exitFluid(share);
+    }
+
+    function _enterFluid() internal {
+        address underlyingAssetCached = underlyingAsset;
+        address fTokenCached = fToken;
+        uint256 underlyingAssetBalance = IERC20(underlyingAssetCached).balanceOf(address(this));
+
+        if (underlyingAssetBalance == 0) {
+            return;
+        }
+
+        IERC20(underlyingAssetCached).safeIncreaseAllowance(fTokenCached, underlyingAssetBalance);
+        IFluidToken(fTokenCached).deposit(underlyingAssetBalance, address(this));
+        lastAssetsValue = IFluidToken(fTokenCached).convertToAssets(IERC20(fTokenCached).balanceOf(address(this)));
+    }
+
+    function _exitFluid(uint256 share) internal {
+        require(share > 0, Errors.ZeroAmount());
+        require(share <= MAX_BPS, Errors.IncorrectAmount());
+
+        address fTokenCached = fToken;
+        uint256 fTokenAmountToRedeem = IERC20(fTokenCached).balanceOf(address(this)).mulDiv(share, MAX_BPS);
+
+        if (fTokenAmountToRedeem == 0) {
+            return;
+        }
+
+        IFluidToken(fTokenCached).redeem(fTokenAmountToRedeem, address(this), address(this));
+        lastAssetsValue = IFluidToken(fTokenCached).convertToAssets(IERC20(fTokenCached).balanceOf(address(this)));
+    }
+
+    function _calculateAccruedAssetsValue() private view returns (uint256) {
+        address fTokenCached = fToken;
+        uint256 lastAssetsValueCached = lastAssetsValue;
+        uint256 currentAssetsValue = IFluidToken(fTokenCached).convertToAssets(
+            IERC20(fTokenCached).balanceOf(address(this))
+        );
+
+        if (currentAssetsValue > lastAssetsValueCached) {
+            return currentAssetsValue - lastAssetsValueCached;
+        }
+
+        return 0;
+    }
+
+    function _harvest(bytes32 _stateId, address _treasury, uint256 _feePct) internal override {
+        AutomaticHarvestLocalVars memory vars;
+        vars.fTokenCached = fToken;
+        vars.merkleRewardToken = merkleRewardToken;
+
+        vars.accruedAssetsValue = _calculateAccruedAssetsValue();
+
+        if (vars.accruedAssetsValue > 0) {
+            vars.accruedFTokenAmount = IFluidToken(vars.fTokenCached).convertToShares(vars.accruedAssetsValue);
+            vars.fTokensToTreasury = vars.accruedFTokenAmount.mulDiv(_feePct, MAX_BPS);
+        }
+
+        if (_stateId == FLUID_SUPPLY_STATE_ID) {
+            if (IERC20(vars.merkleRewardToken).balanceOf(address(this)) > 0) {
+                vars.fTokensAmountBefore = IERC20(vars.fTokenCached).balanceOf(address(this));
+                _swapToInputTokens(vars.merkleRewardToken, underlyingAsset, 0, false);
+                _enterFluid();
+                vars.reinvestFTokenDelta =
+                    IERC20(vars.fTokenCached).balanceOf(address(this)) - vars.fTokensAmountBefore;
+
+                if (vars.reinvestFTokenDelta > 0) {
+                    vars.feeFromReinvest = vars.reinvestFTokenDelta.mulDiv(_feePct, MAX_BPS);
+                    if (vars.feeFromReinvest > 0) {
+                        vars.fTokensToTreasury += vars.feeFromReinvest;
+                    }
+                }
+            }
+        }
+
+        if (vars.fTokensToTreasury > 0) {
+            IERC20(vars.fTokenCached).safeTransfer(_treasury, vars.fTokensToTreasury);
+        }
+
+        lastAssetsValue = IFluidToken(vars.fTokenCached).convertToAssets(
+            IERC20(vars.fTokenCached).balanceOf(address(this))
+        );
+    }
+}