Depositing & Withdrawing

Learn how to deposit assets into Flux vaults and withdraw them when needed. This guide covers all withdrawal types and best practices for liquidity providers.

Overview

Flux vaults implement the ERC4626 standard, providing a familiar interface for deposits and withdrawals. As an LP, you:

1. Deposit base assets (USDC, WETH, etc.)

2. Receive vault shares representing your claim

3. Earn yield from manager interest payments

4. Withdraw anytime (subject to available liquidity)

---

Depositing Assets

Basic Deposit Flow

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IFluxVault} from "@flux/interfaces/IFluxVault.sol";

// 1. Approve vault to spend your tokens
IERC20 baseAsset = IERC20(vault.asset());
baseAsset.approve(address(vault), depositAmount);

// 2. Deposit and receive shares
uint256 shares = IFluxVault(vault).deposit(depositAmount, msg.sender);

// shares now represent your claim on vault assets

Preview Deposit

Always preview deposits to know exactly how many shares you'll receive:

// Preview how many shares you'll get
uint256 expectedShares = vault.previewDeposit(depositAmount);

// Check if acceptable
require(expectedShares >= minSharesExpected, "Slippage too high");

// Execute deposit
uint256 actualShares = vault.deposit(depositAmount, msg.sender);

Mint Shares (Alternative Method)

Instead of specifying deposit amount, you can specify desired shares:

// Specify how many shares you want
uint256 desiredShares = 1000e18;

// Preview how much it will cost
uint256 assetsNeeded = vault.previewMint(desiredShares);

// Approve and mint
baseAsset.approve(address(vault), assetsNeeded);
uint256 actualAssetsCost = vault.mint(desiredShares, msg.sender);

Deposit Limits

Check vault deposit limits before depositing:

// Maximum you can deposit
uint256 maxDeposit = vault.maxDeposit(msg.sender);
require(depositAmount <= maxDeposit, "Exceeds deposit limit");

// Maximum shares you can mint
uint256 maxMint = vault.maxMint(msg.sender);

Deposit limits can be affected by:

• Vault capacity caps

• Access policy restrictions

• Per-user deposit limits

• Strategy-specific constraints

First Deposit Protection

The first depositor to a vault should be aware of share manipulation risks:

// Check if vault has existing deposits
uint256 totalAssets = vault.totalAssets();

if (totalAssets == 0) {
    // First depositor - consider depositing a meaningful amount
    // to prevent share price manipulation
    require(depositAmount >= 1000e6, "First deposit too small");
}

---

Withdrawing Assets

Flux vaults implement ERC4626 standard withdrawals. Withdrawals succeed immediately if liquidity is available, otherwise they revert.

Standard Withdrawal

Withdraw immediately if liquidity is available:

// Preview withdrawal
uint256 expectedAssets = vault.previewRedeem(shares);

// Check if enough liquidity
uint256 availableLiquidity = vault.getIdleLiquidity();
require(expectedAssets <= availableLiquidity, "Insufficient liquidity");

// Execute withdrawal
uint256 assets = vault.redeem(shares, msg.sender, msg.sender);

When it works:

• Sufficient idle liquidity available

• Vault utilization <100%

• Normal market conditions

When it fails:

• Vault has insufficient idle liquidity

• Must wait for managers to repay

• High utilization (>95%)

What Happens When Liquidity is Low?

If the vault has insufficient liquidity for your withdrawal:

1. Transaction reverts - Your withdrawal fails with "Insufficient liquidity" error

2. Wait for repayments - Managers naturally repay debt over time

3. ADA may help - Vault's ADA Manager may trigger Auto-Deleveraging to free liquidity

Auto-Deallocating (ADA) for LP Protection

When vault utilization is very high (typically >95%), the vault's ADA Manager can force-close healthy manager positions to free up liquidity for LP withdrawals.

Important: LPs don't trigger ADA directly - it's executed by the vault's designated ADA Manager (usually the vault creator).

See Auto-Deallocating for details on how ADA protects LPs during high utilization.

---

Detailed Withdrawal Methods

Standard Withdrawal: Redeem

// Redeem specific amount of shares
function redeem(
    uint256 shares,
    address receiver,
    address owner
) external returns (uint256 assets);

// Example
uint256 assets = vault.redeem(
    1000e18,        // shares to burn
    msg.sender,     // receive assets
    msg.sender      // owner of shares
);

Standard Withdrawal: Withdraw

// Withdraw specific amount of assets
function withdraw(
    uint256 assets,
    address receiver,
    address owner
) external returns (uint256 shares);

// Example
uint256 shares = vault.withdraw(
    500e6,          // assets to receive
    msg.sender,     // receive assets
    msg.sender      // owner of shares
);

Redeem vs Withdraw:

• redeem(): Specify shares to burn → receive assets

• withdraw(): Specify assets to receive → burn shares

---

Best Practices

Before Depositing

1. Verify vault strategy: Understand risks and parameters

2. Check access policy: Ensure you're allowed to deposit

3. Review vault health: Check utilization and bad debt

4. Preview deposit: Know exact shares you'll receive

// Comprehensive pre-deposit checks
function safeDeposit(address vault, uint256 amount) external {
    IFluxVault v = IFluxVault(vault);

    // 1. Check access
    require(v.maxDeposit(msg.sender) >= amount, "Deposit not allowed");

    // 2. Check vault health
    require(v.totalAssets() > 0, "Empty vault");
    uint256 utilization = v.totalBorrowed() * 100 / v.totalAssets();
    require(utilization < 95, "Vault over-utilized");

    // 3. Preview and validate
    uint256 shares = v.previewDeposit(amount);
    require(shares > 0, "Zero shares");

    // 4. Execute
    IERC20(v.asset()).approve(vault, amount);
    v.deposit(amount, msg.sender);
}

Before Withdrawing

1. Check liquidity: Is there enough idle liquidity?

2. Preview withdrawal: Know exact assets you'll receive

3. Check utilization: High utilization means withdrawal may fail

4. Be patient: If failed, wait for managers to repay or for ADA

// Smart withdrawal with liquidity check
function smartWithdraw(address vault, uint256 shares) external {
    IFluxVault v = IFluxVault(vault);

    uint256 assets = v.previewRedeem(shares);
    uint256 available = v.getIdleLiquidity();

    if (assets <= available) {
        // Sufficient liquidity - withdraw immediately
        v.redeem(shares, msg.sender, msg.sender);
    } else {
        // Insufficient liquidity
        revert("Insufficient liquidity - wait for repayments or ADA");
    }
}

Monitoring Your Position

// Track your position value
function getPositionValue(address vault) external view returns (
    uint256 shares,
    uint256 assets,
    uint256 depositedAssets,
    uint256 profit
) {
    IFluxVault v = IFluxVault(vault);

    shares = v.balanceOf(msg.sender);
    assets = v.convertToAssets(shares);

    // Track deposits off-chain or via events
    depositedAssets = getUserDeposited(vault, msg.sender);

    profit = assets > depositedAssets ? assets - depositedAssets : 0;
}

---

Common Issues

Issue 1: Deposit Reverts

// ❌ Fails: Insufficient approval
vault.deposit(1000e6, msg.sender);

// ✅ Fix: Approve first
IERC20(vault.asset()).approve(address(vault), 1000e6);
vault.deposit(1000e6, msg.sender);

Issue 2: Withdrawal Fails (No Liquidity)

// ❌ Fails: Insufficient liquidity
vault.redeem(shares, msg.sender, msg.sender);

// ✅ Fix: Wait and try again later
// - Managers will repay over time
// - ADA Manager may free up liquidity
// - Check vault utilization before retrying

Issue 3: Slippage

// ❌ Bad: No slippage protection
vault.deposit(amount, msg.sender);

// ✅ Good: Slippage protection
uint256 minShares = vault.previewDeposit(amount) * 99 / 100;
uint256 actualShares = vault.deposit(amount, msg.sender);
require(actualShares >= minShares, "Slippage too high");

---

Gas Optimization

// ❌ Expensive: Multiple calls
uint256 assets1 = vault.convertToAssets(shares);
uint256 assets2 = vault.previewRedeem(shares);  // Same result

// ✅ Cheaper: Single call
uint256 assets = vault.previewRedeem(shares);

---

Security Considerations

Reentrancy Protection

Flux vaults have built-in reentrancy protection, but integrators should still be careful:

// Safe pattern
function depositAndStake(address vault, uint256 amount) external nonReentrant {
    // 1. External call to deposit
    uint256 shares = IFluxVault(vault).deposit(amount, address(this));

    // 2. Update state after external call
    userShares[msg.sender] = shares;
}

Approval Management

// ❌ Bad: Infinite approval
token.approve(vault, type(uint256).max);

// ✅ Good: Exact approval
token.approve(vault, depositAmount);

// ✅ Better: Reset after use
token.approve(vault, depositAmount);
vault.deposit(depositAmount, msg.sender);
token.approve(vault, 0);

---

Related Documentation

• Understanding Shares & Returns - How share value grows

• Auto-Deallocating (ADA) - LP liquidity protection

• LP Integration Guide - Full integration guide