Strategies

Strategy Contracts define the economic parameters and risk management rules for Flux vaults. They determine interest rates, collateralization requirements, allowed assets, and liquidation behavior.

What is a Strategy?

A Strategy is a smart contract that implements the IStrategy interface and provides:

• Interest Rates: How much managers pay to borrow capital

• Risk Parameters: Minimum bond ratios, liquidation thresholds

• Asset Allowlist: Which wrappers managers can use

• Fee Structure: Protocol fees, curator fees

• Liquidation Behavior: Profit margins for liquidators

Think of strategies as "economic policy modules" that vault creators can plug into their vaults.

Why Strategies?

Strategies separate economic policy from vault logic:

Modularity

• Vaults handle position tracking and accounting

• Strategies handle economic rules and risk management

• Clean separation of concerns

Flexibility

• Different vaults can use different strategies

• Vault creators choose risk/return profiles

• Permissionless strategy deployment

Immutability Options

• Immutable strategies: Parameters locked forever (no governance risk)

• Mutable strategies: Parameters updatable with timelock (flexibility)

---

The IStrategy Interface

All strategies implement:

interface IStrategy {
    // ============================================================================
    // HEALTH EVALUATION
    // ============================================================================

    /**
     * @notice Check if position can be liquidated
     * @return canLiquidate Whether position is unhealthy
     * @return minPayment Minimum payment liquidator must provide
     * @return oraclePrices Array of oracle prices used
     */
    function evaluateLiquidation(address vault, address manager)
        external view returns (
            bool canLiquidate,
            uint256 minPayment,
            OraclePrice[] memory oraclePrices
        );

    /**
     * @notice Check if position can be auto-deleveraged
     * @return canADL Whether position can be ADL'd
     * @return managerNetEquityUSD Manager's net equity in USD
     */
    function evaluateADL(address vault, address manager)
        external view returns (bool canADL, uint256 managerNetEquityUSD);

    // ============================================================================
    // RATE PARAMETERS
    // ============================================================================

    function getGlobalBorrowRatePerSecond() external view returns (uint256);
    function getVaultCreatorFeeRate() external view returns (uint256);
    function annualRate() external view returns (uint64);
    function vaultCreatorFeeRate() external view returns (uint16);

    // ============================================================================
    // RISK PARAMETERS
    // ============================================================================

    function minBondRatio() external view returns (uint64);
    function liquidationThreshold() external view returns (uint64);
    function liquidationProfitMargin() external view returns (uint64);
    function adlThreshold() external view returns (uint64);
    function adlUtilizationThreshold() external view returns (uint64);

    // ============================================================================
    // ASSET FILTERING
    // ============================================================================

    function isAssetAllowed(address wrapper) external view returns (bool);
}

Strategy Extensibility: Beyond Oracle Prices

The evaluateLiquidation() and evaluateADL() functions provide powerful extensibility beyond simple oracle-based health checks. Custom strategies can implement holistic risk assessment by incorporating:

On-Chain Data:

• Oracle prices (Chainlink, etc.)

• On-chain liquidity depth and slippage analysis

• Historical volatility calculations

• Cross-protocol position correlations

Off-Chain Data Feeds:

• Chainlink Functions for custom computations

• API3 first-party oracles

• UMA's optimistic oracle for complex assertions

• Custom data via decentralized oracle networks

Advanced Risk Logic:

• Time-based conditions (e.g., no liquidations during high volatility periods)

• Multi-factor risk scoring (liquidity + volatility + concentration)

• Strategy-specific risk models (e.g., impermanent loss for LP positions)

• Circuit breakers based on market conditions

Example: Advanced Liquidation Logic

function evaluateLiquidation(address vault, address manager)
    external view returns (bool canLiquidate, uint256 minPayment, OraclePrice[] memory)
{
    // Standard health check
    uint256 healthRatio = calculateHealthRatio(vault, manager);

    // Advanced checks
    bool sufficientLiquidity = checkLiquidityDepth(manager);
    bool volatilityAcceptable = checkVolatility();  // Off-chain data via Chainlink
    bool concentrationRisk = assessConcentrationRisk(manager);

    // Holistic decision
    canLiquidate = healthRatio < liquidationThreshold
                   && sufficientLiquidity
                   && volatilityAcceptable
                   && !concentrationRisk;

    // Custom pricing based on market conditions
    minPayment = calculateDynamicPayment(healthRatio, volatility);

    return (canLiquidate, minPayment, oraclePrices);
}

This extensibility allows strategies to implement sophisticated risk management that goes far beyond simple collateral ratio checks.

---

Built-In Strategy Types

1. ImmutableFixedRateStrategy

Parameters are set at deployment and cannot be changed.

Use Case: Maximum security for depositors - no governance risk.

Deployment:

address strategy = strategyFactory.deployImmutableStrategy(
    allowedAssets,  // Array of wrapper addresses
    StrategyParams({
        minBondRatio: 0.2e18,           // 20% bond required
        liquidationBuffer: 0.1e18,       // 10% buffer before liquidation
        annualRate: 0.1e18,              // 10% APR
        curatorFeeRate: 1000,            // 10% curator fee (1000 basis points)
        liquidationProfitMargin: 0.01e18 // 1% liquidator profit
    })
);

Key Features:

• Parameters immutable forever

• Assets cannot be removed (only added via mutable variant)

• No governance risk for depositors

• Ideal for conservative vaults

2. MutableFixedRateStrategy

Parameters can be updated with 7-day timelock.

Use Case: Flexibility to adapt to market conditions while giving depositors time to exit.

Deployment:

address strategy = strategyFactory.deployMutableStrategy(
    initialAssets,  // Initial allowed assets
    StrategyParams({...}),
    owner           // Address that can queue parameter changes
);

Updatable Parameters:

• Annual rate (interest rate)

• Curator fee rate

• Allowed assets (can add, cannot remove)

Timelock Protection:

// Owner queues parameter change
mutableStrategy.queueAnnualRateChange(0.12e18);  // Change to 12% APR

// 7 days later...
mutableStrategy.executeAnnualRateChange();  // Apply change

3. MutableFlexibleMarginStrategy

Advanced strategy with flexible margin requirements.

Features:

• Dynamic bond ratios based on position composition

• Advanced ADL (Auto-Deleveraging) logic

• Configurable risk buckets

Use Case: Sophisticated vaults with complex risk management needs.

---

Key Strategy Parameters

1. Minimum Bond Ratio

Definition: Minimum collateral a manager must post to borrow capital.

minBondRatio = 0.2e18  // 20%

Example:

• Manager wants to borrow 100K USDC

• Required bond: 100K × 20% = 20K USDC

• Effective leverage: 5x (100K / 20K)

How It's Used:

// When manager borrows
function locked_borrow(uint256 amount) external {
    uint256 requiredBond = amount * minBondRatio / 1e18;
    require(bondBalance >= requiredBond, "Insufficient bond");
    // ...
}

2. Liquidation Buffer

Definition: Safety margin before position becomes liquidatable.

liquidationBuffer = 0.1e18  // 10%

Liquidation Threshold Calculation:

liquidationThreshold = 1e18 + minBondRatio - liquidationBuffer
                     = 1.0 + 0.2 - 0.1
                     = 1.1 (110%)

Position Health:

Health Ratio = Total Position Value / True Debt

If Health Ratio < 1.1 → Liquidatable
If Health Ratio ≥ 1.1 → Healthy

Example:

• Manager's total position value: 55K USDC

• True debt (principal + interest): 50K USDC

• Health ratio: 55K / 50K = 1.1 (110%) ✓ Just healthy

• If value drops to 54.9K: 54.9K / 50K = 1.098 (109.8%) ✗ Liquidatable!

3. Annual Rate

Definition: Interest rate managers pay on borrowed capital.

annualRate = 0.1e18  // 10% APR

Conversion to Per-Second Rate:

function getGlobalBorrowRatePerSecond() public view returns (uint256) {
    // APR → rate per second
    return annualRate * 1e18 / 365 days;
}

Interest Calculation:

// Interest accrual
newLpIndex = oldLpIndex * (1 + ratePerSecond * timeElapsed);

// Manager's true debt
trueDebt = principalDebt * (currentLpIndex / snapshotLpIndex);

Example:

• Manager borrows 100K USDC

• Annual rate: 10%

• After 1 year: 100K × 1.10 = 110K USDC (assuming no compounding)

• Interest owed: 10K USDC

4. Curator Fee Rate

Definition: Percentage of interest paid that goes to vault creator.

curatorFeeRate = 1000  // 10% (basis points, max 5000 = 50%)

Fee Distribution:

Interest Earned: 10K USDC
  ├─ Protocol Fee (10%): 1K USDC
  ├─ Curator Fee (10%): 1K USDC
  └─ LP Share (80%): 8K USDC

Calculation:

uint256 interest = 10_000e6;  // 10K USDC

uint256 protocolFee = interest * protocolFeeBps / 10000;  // 1K
uint256 curatorFee = interest * curatorFeeRate / 10000;   // 1K
uint256 lpShare = interest - protocolFee - curatorFee;    // 8K

5. Liquidation Profit Margin

Definition: Profit liquidators earn when liquidating underwater positions.

liquidationProfitMargin = 0.01e18  // 1%

Liquidation Payment Calculation:

Case 1: Healthy Position (collateral ≥ debt)

Liquidator pays: Full debt amount
Liquidator bonus: 0% (zero bonus)

Case 2: Underwater Position (collateral < debt)

Liquidator pays: (1 - liquidationProfitMargin) × collateralValue

Examples:
- 1% margin: pays 99% of collateral, keeps 1% profit
- 0% margin: pays 100% of collateral, break-even (altruistic)
- 20% margin: pays 80% of collateral, keeps 20% profit (max)

Example:

• Manager's collateral: 45K USDC (underwater!)

• True debt: 50K USDC

• Liquidation profit margin: 1%

• Liquidator pays: 45K × (1 - 0.01) = 44.55K USDC

• Liquidator receives: 45K USDC collateral

• Liquidator profit: 45K - 44.55K = 450 USDC (1%)

6. ADL Parameters

Auto-Deleveraging (ADL) forces position closure when vault utilization is too high.

ADL Threshold

adlThreshold = 1.2e18  // 120%

Position can be ADL'd when:

healthRatio < adlThreshold AND vaultUtilization > adlUtilizationThreshold

ADL Utilization Threshold

adlUtilizationThreshold = 0.95e18  // 95%

Example:

• Vault utilization: 96% (above 95% threshold)

• Manager's health ratio: 1.15 (115%, below 120% threshold)

• Result: Position can be ADL'd to reduce vault utilization

Why ADL?

• Protects LPs when vault is nearly fully utilized

• Ensures liquidity for withdrawals

• Prevents vault from becoming "stuck"

---

Asset Allowlist

Strategies define which asset wrappers managers can use.

Immutable Strategy Allowlist

// Set at deployment, cannot be changed
address[] memory allowedAssets = [
    wethWrapper,
    wbtcWrapper,
    usdcWrapper,
    aaveUsdcWrapper
];

address strategy = strategyFactory.deployImmutableStrategy(
    allowedAssets,
    params
);

Check During Unlock:

function evaluateLiquidation(address vault, address manager) external view {
    IAsset[] memory wrappers = IFluxVault(vault).getRegisteredWrappers(manager);

    for (uint i = 0; i < wrappers.length; i++) {
        require(isAssetAllowed(address(wrappers[i])), "Asset not allowed");
    }
    // ...
}

Mutable Strategy Allowlist

// Can add assets (cannot remove)
mutableStrategy.queueAddAsset(newWrapper);

// 7 days later...
mutableStrategy.executeAddAsset();

Why Can't Assets Be Removed? Removing an asset would break existing manager positions using that asset.

---

Strategy Evaluation Functions

evaluateLiquidation

Called by vault at end of unlock() callback to check position health.

function evaluateLiquidation(address vault, address manager)
    external view returns (
        bool canLiquidate,
        uint256 minPayment,
        OraclePrice[] memory oraclePrices
    )
{
    // 1. Get manager position
    uint256 trueDebt = vault.getManagerTrueDebt(manager);
    uint256 bondValue = vault.getBondValue(manager);
    uint256 workingCapitalValue = vault.getWorkingCapitalValue(manager);

    // 2. Calculate total collateral
    uint256 wrapperValue = 0;
    IAsset[] memory wrappers = vault.getRegisteredWrappers(manager);
    for (uint i = 0; i < wrappers.length; i++) {
        // Check asset is allowed
        require(isAssetAllowed(address(wrappers[i])), "Asset not allowed");

        // Sum wrapper values
        wrapperValue += wrappers[i].getValue(vault, manager, positionId);
    }

    uint256 totalValue = bondValue + workingCapitalValue + wrapperValue;

    // 3. Calculate health ratio
    uint256 healthRatio = (totalValue * 1e18) / trueDebt;

    // 4. Check if liquidatable
    canLiquidate = healthRatio < liquidationThreshold;

    // 5. Calculate minimum payment
    if (canLiquidate) {
        if (totalValue >= trueDebt) {
            // Healthy: pay full debt
            minPayment = trueDebt;
        } else {
            // Underwater: pay discounted collateral
            minPayment = totalValue * (1e18 - liquidationProfitMargin) / 1e18;
        }
    }

    return (canLiquidate, minPayment, oraclePrices);
}

evaluateADL

Checks if position can be auto-deleveraged due to high vault utilization.

function evaluateADL(address vault, address manager)
    external view returns (bool canADL, uint256 managerNetEquityUSD)
{
    // 1. Check vault utilization
    uint256 utilization = calculateUtilization(vault);
    if (utilization < adlUtilizationThreshold) {
        return (false, 0);  // Vault not stressed
    }

    // 2. Check manager health
    uint256 trueDebt = vault.getManagerTrueDebt(manager);
    uint256 totalValue = vault.getTotalPositionValue(manager);
    uint256 healthRatio = (totalValue * 1e18) / trueDebt;

    if (healthRatio >= adlThreshold) {
        return (false, 0);  // Manager too healthy for ADL
    }

    // 3. Calculate manager equity
    managerNetEquityUSD = totalValue - trueDebt;

    return (true, managerNetEquityUSD);
}

---

Deploying Strategies

Using StrategyFactory

The StrategyFactory enables permissionless strategy deployment:

interface IStrategyFactory {
    struct StrategyParams {
        uint256 minBondRatio;           // e.g., 0.2e18 = 20%
        uint256 liquidationBuffer;      // e.g., 0.1e18 = 10%
        uint256 annualRate;             // e.g., 0.1e18 = 10% APR
        uint256 curatorFeeRate;         // e.g., 1000 = 10% (max 5000)
        uint256 liquidationProfitMargin; // e.g., 0.01e18 = 1%
    }

    function deployImmutableStrategy(
        address[] calldata allowedAssets,
        StrategyParams calldata params
    ) external returns (address strategy);

    function deployMutableStrategy(
        address[] calldata initialAssets,
        StrategyParams calldata params,
        address owner
    ) external returns (address strategy);
}

Parameter Validation

Factory validates parameters on deployment:

function deployImmutableStrategy(...) external returns (address) {
    // Validate minBondRatio (0-100%)
    require(params.minBondRatio <= 1e18, "Bond ratio too high");

    // Validate liquidationBuffer < minBondRatio
    require(params.liquidationBuffer < params.minBondRatio, "Buffer too high");

    // Validate curatorFeeRate (0-50%)
    require(params.curatorFeeRate <= 5000, "Fee rate too high");

    // Validate liquidationProfitMargin (0-20%)
    require(params.liquidationProfitMargin <= 0.2e18, "Profit margin too high");

    // Deploy strategy
    address strategy = address(new ImmutableFixedRateStrategy(
        allowedAssets,
        params,
        factory
    ));

    emit StrategyDeployed(strategy, false);  // false = immutable
    return strategy;
}

---

Strategy Selection Guide

For Conservative Vaults

Recommended: Immutable strategy with:

• High bond ratio: 25-30% (3-4x leverage)

• Large liquidation buffer: 15-20%

• Moderate interest rate: 5-8% APR

• Low curator fee: 0-5%

• Conservative liquidation margin: 1-2%

Example:

StrategyParams({
    minBondRatio: 0.3e18,           // 30% bond (3.33x leverage)
    liquidationBuffer: 0.2e18,       // 20% buffer
    annualRate: 0.06e18,             // 6% APR
    curatorFeeRate: 500,             // 5% curator fee
    liquidationProfitMargin: 0.01e18 // 1% liquidator profit
})

For Aggressive Vaults

Recommended: Mutable strategy with:

• Low bond ratio: 15-20% (5-6.67x leverage)

• Small liquidation buffer: 5-10%

• High interest rate: 10-15% APR

• High curator fee: 10-20%

• Generous liquidation margin: 5-10%

Example:

StrategyParams({
    minBondRatio: 0.15e18,          // 15% bond (6.67x leverage)
    liquidationBuffer: 0.05e18,      // 5% buffer
    annualRate: 0.12e18,             // 12% APR
    curatorFeeRate: 1500,            // 15% curator fee
    liquidationProfitMargin: 0.05e18 // 5% liquidator profit
})

For Altruistic/Public Goods Vaults

Recommended: Immutable strategy with:

• Moderate bond ratio: 20-25%

• Moderate buffer: 10-15%

• Low interest rate: 3-5% APR

• Zero curator fee: 0%

• Zero liquidation margin: 0% (break-even)

Example:

StrategyParams({
    minBondRatio: 0.2e18,           // 20% bond
    liquidationBuffer: 0.1e18,       // 10% buffer
    annualRate: 0.04e18,             // 4% APR
    curatorFeeRate: 0,               // 0% curator fee
    liquidationProfitMargin: 0       // 0% profit (altruistic)
})

---

Strategy Lifecycle

1. Deployment

address strategy = strategyFactory.deployImmutableStrategy(
    allowedAssets,
    params
);

2. Vault Creation

address vault = fluxVaultFactory.createVault(
    baseAsset,
    baseAssetWrapper,
    IStrategy(strategy),
    accessPolicy,
    "My Vault",
    "MV"
);

3. Position Management

// Vault queries strategy during unlock
(bool canLiquidate,,) = strategy.evaluateLiquidation(vault, manager);
require(!canLiquidate, "Position unhealthy");

4. Parameter Updates (Mutable Only)

// Queue change
mutableStrategy.queueAnnualRateChange(0.12e18);

// 7 days later
mutableStrategy.executeAnnualRateChange();

---

Best Practices

For Strategy Deployers

1. Choose immutable when possible: No governance risk for depositors

2. Conservative parameters: Start conservative, can always deploy new strategy

3. Test thoroughly: Deploy on testnet first

4. Document clearly: Explain parameter choices to vault creators

5. Consider edge cases: What happens at extremes (100% utilization, etc.)?

For Vault Creators

1. Understand parameters: Know how they affect LPs and managers

2. Match risk tolerance: Choose strategy matching your LP base

3. Vet allowed assets: Ensure oracle support and liquidity

4. Monitor performance: Track interest rates, liquidations, utilization

5. Communicate clearly: Tell LPs what strategy you're using and why

For Managers

1. Know the rules: Understand bond ratio, liquidation threshold

2. Monitor health: Track your health ratio constantly

3. Maintain buffer: Don't get too close to liquidation threshold

4. Calculate costs: Factor in interest when planning trades

5. Respect allowlist: Only use whitelisted asset wrappers

---

Advanced Features

Custom Strategy Development

You can develop custom strategies implementing IStrategy:

contract MyCustomStrategy is IStrategy {
    // Implement all interface functions
    function evaluateLiquidation(address vault, address manager)
        external view returns (bool, uint256, OraclePrice[] memory)
    {
        // Custom liquidation logic
    }

    // ... other functions
}

Requirements:

• Implement all IStrategy functions

• Ensure gas efficiency (called frequently)

• Handle edge cases gracefully

• Document behavior clearly

Multi-Strategy Vaults (Not Supported)

Each vault has one strategy set at deployment. Cannot be changed.

Why? Prevents rug pulls and ensures predictable behavior for depositors.

Alternative: Deploy multiple vaults with different strategies.