Risk Management

This guide helps managers understand and mitigate risks when borrowing from Flux vaults. Learn how to monitor your positions, avoid liquidation, and operate safely with leverage.

Table of Contents

1. Understanding Your Risk Profile

2. Health Monitoring

3. Liquidation Prevention

4. ADL Prevention

5. Leverage Management

6. Multi-Asset Position Risks

7. Market Condition Monitoring

8. Emergency Procedures

9. Tools & Resources

---

Understanding Your Risk Profile

Key Risk Metrics

As a manager, you need to monitor these critical metrics:

Health Ratio = Total Position Value / True Debt

Liquidation Threshold = 1 + minBondRatio - liquidationBuffer

Liquidatable When: Health Ratio < Liquidation Threshold

Example:

• Bond: 20K USDC

• Borrowed: 80K USDC (4x leverage)

• Wrapper collateral: 50K USDC worth of WETH

• Total position value: 70K USDC (20K bond + 50K WETH)

• True debt: 85K USDC (with accrued interest)

• Health ratio: 70K / 85K = 0.823 (82.3%)

• Liquidation threshold: 110%

• Status: LIQUIDATABLE ⚠️

Your Risk Parameters

Different vaults have different risk parameters. Check your vault's strategy:

const strategy = await vault.STRATEGY();

// Critical parameters
const minBondRatio = await strategy.minBondRatio(); // e.g., 0.2e18 = 20%
const liquidationBuffer = await strategy.liquidationBuffer(); // e.g., 0.1e18 = 10%
const adlThreshold = await strategy.adlThreshold(); // e.g., 0.15e18 = 115%

// Calculate your liquidation threshold
const liquidationThreshold = 1 + minBondRatio - liquidationBuffer;
console.log('Liquidation at health ratio:', liquidationThreshold); // e.g., 1.1 = 110%

---

Health Monitoring

Real-Time Monitoring

Set up continuous monitoring to avoid surprises:

import { ethers } from 'ethers';

async function monitorHealth(vaultAddress: string, managerAddress: string) {
  const vault = new ethers.Contract(vaultAddress, VAULT_ABI, provider);
  const strategy = await vault.STRATEGY();

  // Get position data
  const [principalDebt, bondValue] = await vault.getManagerPosition(managerAddress);
  const trueDebt = await vault.getManagerTrueDebt(managerAddress);
  const totalValue = await vault.getManagerTotalValue(managerAddress);

  // Calculate health ratio
  const healthRatio = totalValue.mul(1e18).div(trueDebt);

  // Get liquidation threshold
  const liquidationThreshold = await strategy.liquidationThreshold();

  // Calculate safety margin
  const safetyMargin = healthRatio.sub(liquidationThreshold).mul(100).div(1e18);

  console.log('━━━ Position Health ━━━');
  console.log('Total Value:', ethers.utils.formatUnits(totalValue, 6), 'USDC');
  console.log('True Debt:', ethers.utils.formatUnits(trueDebt, 6), 'USDC');
  console.log('Health Ratio:', ethers.utils.formatUnits(healthRatio, 18));
  console.log('Liquidation Threshold:', ethers.utils.formatUnits(liquidationThreshold, 18));
  console.log('Safety Margin:', safetyMargin.toString(), '%');

  // Alert levels
  if (healthRatio.lt(liquidationThreshold)) {
    console.error('🚨 CRITICAL: Position is LIQUIDATABLE');
  } else if (healthRatio.sub(liquidationThreshold).lt(ethers.utils.parseUnits('0.05', 18))) {
    console.warn('⚠️  WARNING: Within 5% of liquidation');
  } else if (healthRatio.sub(liquidationThreshold).lt(ethers.utils.parseUnits('0.15', 18))) {
    console.warn('⚡ CAUTION: Within 15% of liquidation');
  } else {
    console.log('✅ SAFE: Position healthy');
  }
}

// Run every 30 seconds
setInterval(() => monitorHealth(VAULT_ADDRESS, MANAGER_ADDRESS), 30_000);

Alert Thresholds

Set up alerts at different safety levels:

Health Ratio	Status	Action Required
> 140%	Safe	Monitor normally
125-140%	Caution	Increase monitoring frequency
115-125%	Warning	Consider reducing leverage or adding collateral
110-115%	Danger	Urgent action needed - reduce position immediately
< 110%	Liquidatable	Position will be liquidated

Monitoring Tools

Option 1: Simple Script

# monitor.sh
while true; do
  cast call $VAULT "getManagerTotalValue(address)(uint256)" $MANAGER
  cast call $VAULT "getManagerTrueDebt(address)(uint256)" $MANAGER
  sleep 30
done

Option 2: Monitoring Service

• Set up alerts via PagerDuty, Telegram, Discord

• Use Tenderly alerts for on-chain monitoring

• Subscribe to Flux SDK event notifications (if available)

Option 3: Dashboard

• Build custom dashboard with health metrics

• Display real-time collateral values

• Show time-until-liquidation estimates

---

Liquidation Prevention

Strategy 1: Maintain Safety Buffer

Never operate at minimum health ratio. Always maintain a buffer above the liquidation threshold:

Recommended Minimum Health Ratio = Liquidation Threshold + 20%

Example:
Liquidation threshold: 110%
Your minimum: 130%

Why?

• Asset prices can drop suddenly

• Interest accrues continuously

• Slippage when adding collateral

• Network congestion can delay transactions

Strategy 2: Add Collateral Proactively

Don't wait until liquidation is imminent:

// Add more bond when health drops below 130%
function addBondProactively(uint256 amount) external {
    bytes memory data = abi.encodeCall(
        this.addBondCallback,
        (amount)
    );
    vault.unlock(data);
}

function addBondCallback(uint256 amount) external {
    // Transfer from manager's wallet to executor first
    asset.transferFrom(msg.sender, address(this), amount);

    // Approve vault
    asset.approve(address(vault), amount);

    // Deposit bond
    vault.locked_depositBond(amount);
}

Strategy 3: Reduce Debt

Pay down debt to improve health ratio:

function partialRepayment(uint256 repayAmount) external {
    bytes memory data = abi.encodeCall(
        this.repayCallback,
        (repayAmount)
    );
    vault.unlock(data);
}

function repayCallback(uint256 repayAmount) external {
    // Transfer repayment funds to executor
    asset.transferFrom(msg.sender, address(this), repayAmount);

    // Approve vault
    asset.approve(address(vault), repayAmount);

    // Deposit to working capital
    vault.locked_depositToWrapper(
        vault.BASE_ASSET_WRAPPER(),
        bytes32(0), // WORKING_CAPITAL_POS_ID
        repayAmount
    );

    // Repay debt (vault automatically uses working capital)
    vault.locked_repay(repayAmount);
}

Strategy 4: Rebalance Collateral

If some collateral assets are falling, rebalance to stronger assets:

function rebalanceToStablecoin() external {
    bytes memory data = abi.encodeCall(
        this.rebalanceCallback,
        ()
    );
    vault.unlock(data);
}

function rebalanceCallback() external {
    // 1. Withdraw declining asset (e.g., WETH dropping)
    vault.locked_withdrawFromWrapper(
        wethWrapper,
        positionId,
        wethAmount
    );

    // 2. Swap to stablecoin on Uniswap
    weth.approve(UNISWAP_ROUTER, wethAmount);
    uniswap.swapExactTokensForTokens(
        wethAmount,
        minUsdcOut,
        [WETH, USDC],
        address(this),
        deadline
    );

    // 3. Deposit stablecoin back to vault
    usdc.approve(address(vault), usdcReceived);
    vault.locked_depositToWrapper(
        vault.BASE_ASSET_WRAPPER(),
        bytes32(0),
        usdcReceived
    );
}

Strategy 5: Emergency Exit

If market conditions deteriorate rapidly, close your position:

function emergencyExit() external {
    bytes memory data = abi.encodeCall(
        this.exitCallback,
        ()
    );
    vault.unlock(data);
}

function exitCallback() external {
    // 1. Withdraw all wrapper collateral
    uint256[] memory balances = getAllWrapperBalances();
    for (uint256 i = 0; i < wrappers.length; i++) {
        vault.locked_withdrawFromWrapper(
            wrappers[i],
            positionIds[i],
            balances[i]
        );
    }

    // 2. Liquidate all to base asset
    swapAllToBaseAsset();

    // 3. Deposit to working capital
    uint256 baseBalance = asset.balanceOf(address(this));
    asset.approve(address(vault), baseBalance);
    vault.locked_depositToWrapper(
        vault.BASE_ASSET_WRAPPER(),
        bytes32(0),
        baseBalance
    );

    // 4. Repay all debt
    vault.locked_repay(0); // 0 = repay all

    // 5. Withdraw bond
    vault.locked_withdrawBond(type(uint256).max);
}

---

ADL Prevention

Understanding ADL

Auto-Deleveraging (ADL) is triggered when:

1. Vault utilization is high (e.g., > 90%)

2. Your health ratio is below ADL threshold (e.g., < 120%)

3. You still have positive equity

Unlike liquidation, with ADL:

• You get your full net equity back

• No liquidation penalty

• But your position is force-closed

ADL Monitoring

async function checkADLRisk(vaultAddress: string, managerAddress: string) {
  const vault = new ethers.Contract(vaultAddress, VAULT_ABI, provider);
  const strategy = await vault.STRATEGY();

  // Check vault utilization
  const totalAssets = await vault.totalAssets();
  const totalBorrowed = await vault.totalBorrowed();
  const utilization = totalBorrowed.mul(1e18).div(totalAssets);

  // Check ADL threshold
  const adlUtilizationThreshold = await strategy.adlUtilizationThreshold();
  const adlThreshold = await strategy.adlThreshold();

  // Check your health
  const totalValue = await vault.getManagerTotalValue(managerAddress);
  const trueDebt = await vault.getManagerTrueDebt(managerAddress);
  const healthRatio = totalValue.mul(1e18).div(trueDebt);

  // Evaluate ADL
  const { canADL, managerNetEquityUSD } = await strategy.evaluateADL(
    vaultAddress,
    managerAddress
  );

  console.log('━━━ ADL Risk Analysis ━━━');
  console.log('Vault Utilization:', ethers.utils.formatUnits(utilization, 16), '%');
  console.log('ADL Utilization Threshold:', ethers.utils.formatUnits(adlUtilizationThreshold, 16), '%');
  console.log('Your Health Ratio:', ethers.utils.formatUnits(healthRatio, 18));
  console.log('ADL Health Threshold:', ethers.utils.formatUnits(adlThreshold, 18));
  console.log('Can be ADL\'d:', canADL);

  if (canADL) {
    console.error('🚨 CRITICAL: Position subject to ADL');
    console.log('Your net equity:', ethers.utils.formatUnits(managerNetEquityUSD, 6), 'USD');
  }
}

Avoiding ADL

Prevention Strategies:

1. Monitor vault utilization

   • If utilization > 85%, increase your safety margin

   • Consider partial position closure

2. Maintain higher health ratios during high utilization

   Normal times: 130% health ratio minimum
   High utilization (>90%): 140% health ratio minimum

3. Voluntary deleveraging

   • Reduce position size proactively

   • Better to control your exit than be ADL'd

---

Leverage Management

Understanding Leverage

Your effective leverage depends on your bond ratio:

Max Leverage = 1 / minBondRatio

Examples:
minBondRatio = 0.2 (20%) → Max leverage = 5x
minBondRatio = 0.3 (30%) → Max leverage = 3.3x
minBondRatio = 0.4 (40%) → Max leverage = 2.5x

Dynamic Leverage Adjustment

Adjust leverage based on market conditions:

// Reduce leverage during volatility
function reduceLeverage(uint256 targetHealthRatio) external {
    uint256 currentHealth = getCurrentHealthRatio();

    if (currentHealth < targetHealthRatio) {
        // Calculate how much to repay
        uint256 repayAmount = calculateRepaymentForHealth(targetHealthRatio);

        // Execute repayment
        repayDebt(repayAmount);
    }
}

// Increase leverage during calm markets (cautiously!)
function increasePosition(uint256 additionalBorrowAmount) external {
    // Only if health is very good
    require(getCurrentHealthRatio() > 1.5e18, "Health too low");

    // Execute borrow
    borrowAndDeploy(additionalBorrowAmount);
}

---

Multi-Asset Position Risks

Correlation Risk

Holding correlated assets provides less diversification:

High Correlation (Risky):

• WETH + stETH + rETH (all ETH derivatives)

• If ETH drops, entire position drops

Low Correlation (Better):

• USDC + WETH + WBTC (different assets)

• Diversified price movements

Liquidity Risk

Not all assets are equally liquid:

High Liquidity (Safe):

• USDC, USDT, DAI

• WETH, WBTC

• Major protocol tokens (UNI, AAVE)

Lower Liquidity (Risky):

• Exotic LP tokens

• NFTs

• Small-cap tokens

Problem: Low liquidity assets may not be sellable during liquidation, causing bad debt.

Volatility Concentration

// Calculate portfolio volatility
function assessVolatilityRisk() {
  const positions = [
    { asset: 'USDC', value: 30_000, volatility: 0.01 }, // 1% daily vol
    { asset: 'WETH', value: 50_000, volatility: 0.05 }, // 5% daily vol
    { asset: 'ALT', value: 20_000, volatility: 0.15 },  // 15% daily vol
  ];

  const totalValue = positions.reduce((sum, p) => sum + p.value, 0);

  const weightedVol = positions.reduce((sum, p) =>
    sum + (p.value / totalValue) * p.volatility, 0
  );

  console.log('Portfolio weighted volatility:', (weightedVol * 100).toFixed(2), '%');

  if (weightedVol > 0.08) {
    console.warn('⚠️  High portfolio volatility - consider reducing exposure');
  }
}

Rebalancing Multi-Asset Positions

Periodically rebalance to maintain target allocation:

function rebalancePortfolio() external {
    // Target: 40% stables, 40% WETH, 20% WBTC
    // Current: 20% stables, 60% WETH, 20% WBTC
    // Action: Sell 20% WETH, buy stables

    bytes memory data = abi.encodeCall(
        this.rebalanceCallback,
        ()
    );
    vault.unlock(data);
}

function rebalanceCallback() external {
    // Get current positions
    uint256 wethBalance = getWrapperBalance(wethWrapper);
    uint256 targetWeth = totalPortfolioValue * 40 / 100;
    uint256 excessWeth = wethBalance - targetWeth;

    // Withdraw excess WETH
    vault.locked_withdrawFromWrapper(wethWrapper, positionId, excessWeth);

    // Swap to stables
    weth.approve(UNISWAP_ROUTER, excessWeth);
    uint256 stables = uniswap.swapExactTokensForTokens(...);

    // Deposit stables
    usdc.approve(address(vault), stables);
    vault.locked_depositToWrapper(baseWrapper, positionId, stables);
}

---

Market Condition Monitoring

Price Oracle Monitoring

Your collateral is valued using oracles. Monitor for:

Oracle Staleness:

async function checkOracleFreshness(assetAddress: string) {
  const oracleRegistry = new ethers.Contract(ORACLE_REGISTRY, ABI, provider);
  const oracleAddress = await oracleRegistry.getOracle(assetAddress);

  const oracle = new ethers.Contract(oracleAddress, CHAINLINK_ABI, provider);
  const latestRound = await oracle.latestRoundData();

  const age = Date.now() / 1000 - latestRound.updatedAt.toNumber();

  console.log('Oracle last updated:', age, 'seconds ago');

  if (age > 3600) { // 1 hour
    console.warn('⚠️  Oracle data is stale - risk of incorrect valuation');
  }
}

Oracle Deviations:

• Check if oracle price differs significantly from market price

• Large deviations can indicate oracle issues

• Compare Chainlink price vs DEX spot price

Volatility Monitoring

Track market volatility to adjust risk:

async function calculateRecentVolatility(assetAddress: string) {
  // Get price history from oracle or DEX
  const prices = await getPriceHistory(assetAddress, 24); // 24 hours

  // Calculate returns
  const returns = [];
  for (let i = 1; i < prices.length; i++) {
    returns.push((prices[i] - prices[i-1]) / prices[i-1]);
  }

  // Calculate standard deviation (volatility)
  const mean = returns.reduce((a, b) => a + b) / returns.length;
  const variance = returns.reduce((sum, r) => sum + Math.pow(r - mean, 2), 0) / returns.length;
  const volatility = Math.sqrt(variance);

  console.log('24h volatility:', (volatility * 100).toFixed(2), '%');

  return volatility;
}

// Adjust position based on volatility
async function volatilityBasedRiskManagement() {
  const vol = await calculateRecentVolatility(WETH_ADDRESS);

  if (vol > 0.05) { // 5% daily volatility
    console.log('High volatility detected - reducing target health ratio');
    const targetHealth = 1.5; // Increase from 1.3 to 1.5
    await adjustHealthRatio(targetHealth);
  }
}

On-Chain Liquidity Monitoring

Monitor DEX liquidity for your collateral assets:

async function checkDEXLiquidity(tokenAddress: string) {
  // Check Uniswap V3 pool
  const pool = new ethers.Contract(POOL_ADDRESS, POOL_ABI, provider);
  const liquidity = await pool.liquidity();

  console.log('Pool liquidity:', ethers.utils.formatUnits(liquidity, 18));

  // Simulate large swap to estimate slippage
  const swapAmount = ethers.utils.parseEther('100'); // Test with 100 ETH
  const quoter = new ethers.Contract(QUOTER_ADDRESS, QUOTER_ABI, provider);

  const { amountOut } = await quoter.quoteExactInputSingle({
    tokenIn: tokenAddress,
    tokenOut: USDC_ADDRESS,
    fee: 3000,
    amountIn: swapAmount,
    sqrtPriceLimitX96: 0,
  });

  // Calculate implied slippage
  const oraclePrice = await getOraclePrice(tokenAddress);
  const executionPrice = amountOut.mul(1e18).div(swapAmount);
  const slippage = oraclePrice.sub(executionPrice).mul(100).div(oraclePrice);

  console.log('Estimated slippage for 100 ETH swap:', slippage.toString(), '%');

  if (slippage.gt(ethers.utils.parseUnits('2', 18))) {
    console.warn('⚠️  High slippage - liquidity may be insufficient');
  }
}

---

Emergency Procedures

If Health Drops Below 115%

Immediate Actions (within 1 hour):

1. Add collateral

   • Transfer from your wallet

   • Deposit via locked_depositBond() or locked_depositToWrapper()

2. Reduce debt

   • Sell assets and repay

   • Move bond to working capital

3. Rebalance to stables

   • Swap volatile assets to USDC

   • Reduces downside risk

If Health Drops Below 112% (Critical)

Urgent Actions (within 15 minutes):

1. Emergency collateral injection

   // Maximum priority - add all available funds
   await emergencyAddCollateral(allAvailableFunds);

2. Partial position close

   // Close 30-50% of position immediately
   await emergencyPartialExit(0.5); // Close 50%

3. Stop loss execution

   • If you can't stabilize, better to exit than be liquidated

   • Liquidation penalty > exit costs

If Liquidatable (Health < 110%)

Your position will be liquidated by bots. At this point:

1. Accept the loss

   • Fighting liquidation is expensive

   • Network fees + slippage may exceed liquidation penalty

2. Learn from it

   • What went wrong?

   • How to prevent next time?

   • Update monitoring and risk rules

---

Tools and Resources

Calculation Helpers

Health Ratio Calculator:

function calculateHealth(totalValue: bigint, trueDebt: bigint): number {
  return Number(totalValue * 10000n / trueDebt) / 100;
}

Required Collateral Calculator:

function calculateRequiredCollateral(
  debt: bigint,
  targetHealthRatio: number
): bigint {
  return debt * BigInt(Math.floor(targetHealthRatio * 100)) / 100n;
}

Interest Projection:

function projectInterest(
  principalDebt: bigint,
  annualRate: bigint,
  days: number
): bigint {
  const dailyRate = annualRate / 365n;
  const periods = BigInt(days);

  // Compound interest formula
  // Future = Principal × (1 + rate)^periods
  // Approximation for on-chain calculation
  const growth = principalDebt * dailyRate * periods / 1e18;

  return principalDebt + growth;
}