Understanding Shares & Returns

Learn how Flux vault shares work, how they accrue value, and how to calculate your returns as a liquidity provider.

Share Mechanics

ERC4626 Standard

Flux vaults implement the ERC4626 tokenized vault standard, which means:

• Vault shares are ERC20 tokens

• Shares are fungible and transferable

• Share value increases over time as interest accrues

• Standard interface across all DeFi protocols

Share-to-Asset Conversion

The core formula:

Share Value = Total Assets / Total Shares

As the vault earns interest, Total Assets grows while Total Shares stays constant, increasing the value of each share.

How Shares Accrue Value

Interest Accumulation

When managers borrow from the vault, they pay interest over time:

Total Assets = Idle Assets + Borrowed Assets + Accrued Interest

As Accrued Interest grows, so does the value of each share.

Example Timeline

Day 0: Initial Deposit

You deposit: 1,000 USDC
Vault total: 10,000 USDC
Shares minted: 1,000 shares
Share price: 1.0 USDC per share

Day 30: After Interest Accrual

Vault total: 10,500 USDC (managers paid 500 USDC interest)
Your shares: 1,000 shares (unchanged)
Share price: 1.05 USDC per share
Your value: 1,050 USDC
Profit: 50 USDC (5% return)

Calculating Returns

Current Share Value

// Get current value of your shares
uint256 shares = vault.balanceOf(msg.sender);
uint256 currentValue = vault.convertToAssets(shares);

// If you deposited 1000 USDC and now have 1050 USDC:
// Return = (1050 - 1000) / 1000 = 5%

Preview Withdrawal

Always preview before withdrawing to know exact amount:

// How much will you receive?
uint256 shares = vault.balanceOf(msg.sender);
uint256 assetsToReceive = vault.previewRedeem(shares);

// Or: how many shares for specific amount?
uint256 desiredAssets = 1000e6;
uint256 sharesNeeded = vault.previewWithdraw(desiredAssets);

APY Calculation

Estimate annual percentage yield:

// Simple APY calculation
uint256 initialValue = deposited;  // Track deposits off-chain
uint256 currentValue = vault.convertToAssets(shares);
uint256 timeElapsed = block.timestamp - depositTime;

// Annualized return
uint256 returnPercent = (currentValue - initialValue) * 1e18 / initialValue;
uint256 apy = returnPercent * 365 days / timeElapsed;

// Example: 5% return over 30 days
// APY = 5% * (365/30) = 60.8%

Real-Time APY

More accurate APY based on current interest rate:

IStrategy strategy = vault.STRATEGY();

// Get current interest rate (annual)
uint256 interestRate = strategy.interestRate();

// Get current utilization
uint256 utilization = vault.totalBorrowed() * 1e18 / vault.totalAssets();

// LP APY = Interest Rate * Utilization
// (LPs only earn on deployed capital)
uint256 lpApy = interestRate * utilization / 1e18;

Share Price Dynamics

Initial Share Price

The first depositor sets the initial share price:

// First deposit
uint256 firstDeposit = 1000e6;  // 1000 USDC
uint256 sharesMinted = vault.deposit(firstDeposit, msg.sender);

// Usually: 1 share = 1 asset
// So: sharesMinted = 1000e18

Subsequent Deposits

New depositors receive shares at current market rate:

// Vault state:
// Total Assets: 10,500 USDC
// Total Shares: 10,000 shares
// Share Price: 1.05 USDC/share

// New deposit:
uint256 newDeposit = 1,000 USDC;
uint256 newShares = vault.deposit(newDeposit, msg.sender);

// New shares = 1,000 / 1.05 = 952.38 shares
// (Fewer shares because price increased)

Share Price Never Decreases (Ideally)

In normal operations:

• Share price increases from interest

• Share price stays flat if no borrowing

• Share price should never decrease

If share price decreases:

• Bad debt has occurred (manager defaulted)

• Emergency withdrawals occurred

• Strategy misconfiguration

• Consider exiting the vault

Factors Affecting Returns

1. Interest Rate

Higher interest rate = Higher returns (but possibly higher risk)

// Fixed rate strategy
uint256 annualRate = strategy.interestRate();  // e.g., 10% = 0.1e18

// Variable rate strategies may adjust based on utilization

2. Utilization

Higher utilization = More capital earning interest

LP APY = Base Interest Rate × Utilization Rate

Example:

• Interest Rate: 20% annual

• Utilization: 80%

• LP APY: 20% × 80% = 16%

uint256 utilization = vault.totalBorrowed() * 100 / vault.totalAssets();

if (utilization > 90) {
    // High returns but low liquidity
} else if (utilization < 50) {
    // Lower returns but high liquidity
}

3. Vault Fees

Some vaults charge creator fees:

uint256 grossApy = interestRate * utilization / 1e18;
uint256 vaultFee = strategy.creatorFeeRate();  // e.g., 10% = 0.1e18

// Net APY = Gross APY * (1 - Fee)
uint256 netApy = grossApy * (1e18 - vaultFee) / 1e18;

4. Manager Performance

Returns depend on managers:

• Paying interest on time

• Not getting liquidated

• Not defaulting (creating bad debt)

Return Scenarios

Scenario 1: Optimal Performance

Deposit: 10,000 USDC
Interest Rate: 15% annual
Utilization: 90%
Vault Fee: 5%

Gross APY: 15% × 90% = 13.5%
Net APY: 13.5% × (1 - 5%) = 12.825%

After 1 year: 11,282.5 USDC
Profit: 1,282.5 USDC

Scenario 2: Low Utilization

Deposit: 10,000 USDC
Interest Rate: 15% annual
Utilization: 30%
Vault Fee: 5%

Gross APY: 15% × 30% = 4.5%
Net APY: 4.5% × (1 - 5%) = 4.275%

After 1 year: 10,427.5 USDC
Profit: 427.5 USDC

Scenario 3: Bad Debt

Deposit: 10,000 USDC
Value after 6 months: 10,600 USDC
Bad debt event: -1,000 USDC loss
Final value: 9,600 USDC

Loss: -400 USDC (-4%)

Tracking Your Position

Smart Contract View

function getPositionDetails(address vault, address user)
    external
    view
    returns (
        uint256 shares,
        uint256 currentValue,
        uint256 sharePrice
    )
{
    IFluxVault v = IFluxVault(vault);

    shares = v.balanceOf(user);
    currentValue = v.convertToAssets(shares);
    sharePrice = v.convertToAssets(1e18);  // Price of 1 share

    return (shares, currentValue, sharePrice);
}

Off-Chain Tracking

Track deposits to calculate profit:

// On deposit
event Deposited(address user, uint256 assets, uint256 shares, uint256 timestamp);

// Track cumulative deposits
mapping(address => uint256) public totalDeposited;

// Calculate profit
function calculateProfit(address user) external view returns (int256) {
    uint256 currentValue = vault.convertToAssets(vault.balanceOf(user));
    uint256 deposited = totalDeposited[user];

    return int256(currentValue) - int256(deposited);
}

Compounding Returns

Auto-Compounding

Flux vaults automatically compound:

• Interest is added to totalAssets

• Share value increases automatically

• No action required from LPs

This is different from claiming rewards - it's passive compounding.

Manual Compounding

You can manually compound by:

1. Withdrawing all shares

2. Re-depositing assets

3. Getting new shares at current price

But this is unnecessary! Shares already auto-compound. Manual compounding only makes sense if you're moving to a different vault.

Comparing Vault Returns

Return Metrics to Compare

struct VaultMetrics {
    uint256 currentAPY;      // Based on current rate and utilization
    uint256 historicalAPY;   // Based on past performance
    uint256 utilization;     // Higher = more returns but less liquidity
    uint256 totalAssets;     // Larger = more established
    uint256 badDebt;         // Lower is better
    uint256 sharePrice;      // Shows historical performance
}

Example Comparison

Vault	APY	Utilization	Bad Debt	Share Price	Rating
Vault A	15%	85%	0%	1.45	⭐⭐⭐⭐⭐
Vault B	25%	95%	2%	1.18	⭐⭐⭐
Vault C	8%	45%	0%	1.62	⭐⭐⭐⭐

Analysis:

• Vault A: Balanced - good returns, high utilization, no bad debt

• Vault B: Risky - very high APY but has bad debt and overutilized

• Vault C: Conservative - lower returns but safest, established track record

Tax Implications

Taxable Events

1. Deposits: Usually not taxable

2. Share value increase: Unrealized gain (not taxable until sold)

3. Withdrawals: Realized gain (taxable)

4. Share transfers: May be taxable depending on jurisdiction

Tracking for Taxes

// Track cost basis
struct TaxPosition {
    uint256 totalDeposited;     // Cost basis
    uint256 sharesOwned;        // Current shares
    uint256 currentValue;       // Current market value
    uint256 unrealizedGain;     // Current value - cost basis
}

Consult a tax professional - tax treatment varies by jurisdiction.

Advanced: Share Inflation Attack

The Attack

An attacker could:

1. Be the first depositor with 1 wei

2. Donate large amount to vault

3. Inflate share price

4. Make small deposits uneconomical

Flux Protection

Flux vaults include protections:

• Minimum first deposit requirements

• Virtual shares to prevent manipulation

• Rounding that favors the vault

What This Means for LPs

First depositors should:

• Deposit meaningful amounts (>$1000 recommended)

• Check if vault already has deposits

• Be aware of share price manipulation risks

Common Misconceptions

❌ Myth: "I should withdraw and re-deposit to compound"

✅ Reality: Shares auto-compound. Withdrawing and re-depositing just wastes gas.

❌ Myth: "More shares = more money"

✅ Reality: Share value matters, not share count. 100 shares at $1.50 = 150 shares at $1.00

❌ Myth: "APY is guaranteed"

✅ Reality: APY changes with utilization and interest rate. Historical ≠ Future.

❌ Myth: "Share price always goes up"

✅ Reality: Bad debt can decrease share price. Always monitor vault health.

Best Practices

1. Track Your Deposits

// Off-chain tracking
mapping(address => uint256) public depositedAmount;

// Update on deposit
depositedAmount[user] += amount;

// Calculate returns
uint256 profit = currentValue - depositedAmount[user];

2. Monitor Share Price

// Check if share price is decreasing (bad sign)
uint256 currentPrice = vault.convertToAssets(1e18);
require(currentPrice >= lastKnownPrice, "Share price decreased!");

3. Understand Your APY

function realizedAPY() external view returns (uint256) {
    uint256 interestRate = vault.STRATEGY().interestRate();
    uint256 utilization = vault.totalBorrowed() * 1e18 / vault.totalAssets();
    uint256 feeRate = vault.STRATEGY().creatorFeeRate();

    uint256 grossAPY = interestRate * utilization / 1e18;
    uint256 netAPY = grossAPY * (1e18 - feeRate) / 1e18;

    return netAPY;
}

4. Compare Risk-Adjusted Returns

Don't just chase highest APY:

• Consider vault track record

• Check bad debt history

• Review manager quality

• Assess strategy risks

Monitoring Tools

Position Value Dashboard

function getLPDashboard(address vault, address user)
    external
    view
    returns (
        uint256 shares,
        uint256 currentValue,
        uint256 sharePrice,
        uint256 vaultAPY,
        uint256 utilization,
        uint256 myAllocation
    )
{
    IFluxVault v = IFluxVault(vault);

    shares = v.balanceOf(user);
    currentValue = v.convertToAssets(shares);
    sharePrice = v.convertToAssets(1e18);

    uint256 borrowed = v.totalBorrowed();
    uint256 total = v.totalAssets();

    utilization = borrowed * 100 / total;
    vaultAPY = calculateAPY(v);
    myAllocation = currentValue * 100 / total;

    return (shares, currentValue, sharePrice, vaultAPY, utilization, myAllocation);
}

Related Documentation

• Depositing & Withdrawing - How to deposit and withdraw

• Risk Management - Understanding LP risks

• LP Integration Guide - Full integration guide

• Flux Vault - Vault architecture