@venusprotocol/liquidity-hub 0.0.0

package/contracts/adapters/AdapterFlux.sol

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.25;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import { IResourceAdapter } from "../interfaces/IResourceAdapter.sol";
+import { IFToken } from "../interfaces/external/IFToken.sol";
+import { IFluidLendingResolver } from "../interfaces/external/IFluidLendingResolver.sol";
+
+/**
+ * @title AdapterFlux
+ * @author Venus
+ * @notice Stateless adapter for Fluid lending fTokens (ERC-4626). ONE deployment serves every
+ *         YieldGroupFlux that registers an fToken — there is no per-(YieldGroup, fToken) instance,
+ *         no proxy, no clone factory.
+ * @dev Dispatch model: mutating functions (`deposit`, `withdraw`) MUST be invoked via DELEGATECALL
+ *      from a YieldGroupFlux. They execute in the YieldGroup's storage context, so ERC-4626 share
+ *      credits and debits land on the YieldGroup, not this adapter. View functions are invoked via
+ *      normal CALL / STATICCALL with an explicit `holder` argument.
+ *
+ *      Storage-safety invariants enforced by this contract:
+ *      1. Zero `internal`/`private`/`public` state variables are declared. Only `immutable` values
+ *         are used (`_ADAPTER_SELF` and `LENDING_RESOLVER`). Immutables live in bytecode, not
+ *         storage slots, so they're delegatecall-safe.
+ *      2. No inline assembly performs `sstore`.
+ *      3. External calls go to the supplied `resource` (fToken), its `asset()`, or the trusted,
+ *         chain-fixed Fluid `LENDING_RESOLVER` (read-only). No arbitrary user-supplied target.
+ *      4. {onlyDelegateCall} reverts when a mutating function is invoked directly on the adapter,
+ *         preventing accidents that would orphan shares here.
+ *
+ *      No treasury-fee handling: a Fluid fToken delivers exactly the requested `assets` on
+ *      withdraw (the Liquidity layer takes its revenue cut in the supply rate, not per-redeem).
+ *      No gross-up needed.
+ *
+ *      No lifecycle: fTokens are perpetual, so unlike `AdapterFRV` there is no state-machine
+ *      pre-advance — the YieldGroup calls the adapter directly.
+ */
+contract AdapterFlux is IResourceAdapter {
+    using SafeERC20 for IERC20;
+
+    // ============================== State (immutable only) ====================
+
+    /// @notice This adapter's own address, captured at deployment. Used by {onlyDelegateCall} to
+    ///         detect direct invocation. Immutables live in bytecode, not storage.
+    address private immutable _ADAPTER_SELF;
+
+    /// @notice Fluid periphery `LendingResolver` address (chain-fixed). Read-only yieldGroup for spot
+    ///         supply APR + reward rate in `spotAPYBps`.
+    address public immutable LENDING_RESOLVER;
+
+    // ============================== Errors ===================================
+
+    /// @notice A mutating function was invoked directly (not via delegatecall).
+    error NotDelegateCall();
+
+    /// @notice The supplied resolver address was the zero address at construction.
+    error ZeroResolver();
+
+    // ============================== Modifiers ================================
+
+    /// @notice Reverts {NotDelegateCall} when the call is not arriving via delegatecall.
+    /// @dev During a delegatecall, `address(this)` is the caller; during a direct call it equals
+    ///      `_ADAPTER_SELF` (captured at construction).
+    modifier onlyDelegateCall() {
+        if (address(this) == _ADAPTER_SELF) revert NotDelegateCall();
+        _;
+    }
+
+    // ============================== Constructor ==============================
+
+    /// @param lendingResolver_ Fluid `LendingResolver` for this chain.
+    constructor(address lendingResolver_) {
+        if (lendingResolver_ == address(0)) revert ZeroResolver();
+        _ADAPTER_SELF = address(this);
+        LENDING_RESOLVER = lendingResolver_;
+    }
+
+    // ============================== External — mutating =======================
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev `address(this)` here is the YieldGroup (delegatecall context). The YieldGroup already
+    ///      holds `amount` of underlying; we approve the fToken, which then pulls `amount` from the
+    ///      YieldGroup via its `liquidityCallback`. Shares are minted to the YieldGroup.
+    function deposit(address resource, uint256 amount) external override onlyDelegateCall returns (uint256 deposited) {
+        IERC20 assetToken = IERC20(IFToken(resource).asset());
+        assetToken.forceApprove(resource, amount);
+        IFToken(resource).deposit(amount, address(this));
+        return amount;
+    }
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev `address(this)` here is the YieldGroup. `fToken.withdraw` burns its (YieldGroup's)
+    ///      shares and delivers exactly `amount` of underlying directly to `to`.
+    function withdraw(address resource, uint256 amount, address to) external override onlyDelegateCall {
+        IFToken(resource).withdraw(amount, to, address(this));
+    }
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev No-op: Fluid's live `previewRedeem` leaves no block-lazy stored rate to freshen.
+    // solhint-disable-next-line no-empty-blocks
+    function accrue(address resource) external override { }
+
+    // ============================== External — view ==========================
+
+    /// @inheritdoc IResourceAdapter
+    function asset(address resource) external view override returns (address) {
+        return IFToken(resource).asset();
+    }
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev `previewRedeem(balanceOf(holder))` — the per-holder position value (shares × token
+    ///      exchange price, including accrued rewards).
+    function totalAssets(address resource, address holder) external view override returns (uint256) {
+        uint256 shares = IFToken(resource).balanceOf(holder);
+        if (shares == 0) return 0;
+        return IFToken(resource).previewRedeem(shares);
+    }
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev fToken headroom up to `int128.max` (effectively unbounded). The receiver param is
+    ///      ignored by the fToken. The YieldGroup's per-resource cap is the binding control.
+    ///      Pause-blind, like the fToken's own `maxDeposit`; a paused fToken is caught and skipped by
+    ///      the YieldGroup deposit cascade, not gated here.
+    function maxDeposit(address resource) external view override returns (uint256) {
+        return IFToken(resource).maxDeposit(address(this));
+    }
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev `min(Fluid withdrawal-limit, holder balance)`. No treasury-fee deduction — the fToken
+    ///      delivers exactly the requested amount on redeem.
+    ///      Intentionally pause-blind: the fToken's own `maxWithdraw` never reads Fluid's `IS_PAUSED`
+    ///      bit (and no cheap getter exposes it), so this mirrors it. An underlying pause is caught
+    ///      and skipped by the YieldGroup withdraw cascade's `try/catch` — where the real op reverts —
+    ///      not gated here.
+    function maxWithdraw(address resource, address holder) external view override returns (uint256) {
+        return IFToken(resource).maxWithdraw(holder);
+    }
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev Spot APY from the Fluid `LendingResolver`: base `supplyRate` (1e2 precision = already
+    ///      basis points) + `rewardsRate` (1e12 precision, `/1e10` → bps). The `blocksPerYear`
+    ///      parameter is unused — Fluid rates are pre-annualised APRs, not per-block.
+    function spotAPYBps(
+        address resource,
+        uint256 /* blocksPerYear */
+    )
+        external
+        view
+        override
+        returns (uint64)
+    {
+        IFluidLendingResolver.FTokenDetails memory details =
+            IFluidLendingResolver(LENDING_RESOLVER).getFTokenDetails(resource);
+        uint256 apyBps = details.supplyRate + (details.rewardsRate / 1e10);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        return apyBps > type(uint64).max ? type(uint64).max : uint64(apyBps);
+    }
+
+    /// @inheritdoc IResourceAdapter
+    function receiptBalance(address resource, address holder) external view override returns (uint256) {
+        return IFToken(resource).balanceOf(holder);
+    }
+
+    /// @inheritdoc IResourceAdapter
+    /// @dev No-op: a Fluid fToken takes its revenue cut in the supply rate, not per-redeem, so
+    ///      there is no unmodeled exit fee to guard against at registration.
+    function validateRegistration(address resource) external pure override {
+        // No Flux-specific registration precondition. `resource` validity is established by the
+        // YieldGroup's `asset()` probe and `code.length` check at registration time.
+        resource;
+    }
+}