Auto-Deleveraging (ADL)

Auto-Deleveraging (ADL) is Flux's mechanism to protect liquidity providers during periods of extreme vault utilization by allowing controlled reduction of healthy-but-risky manager positions.

What is ADL?

Auto-Deleveraging (ADL) is a protective measure that allows a vault to close out manager positions when:

1. The vault has extremely high utilization (typically ≥95%)

2. The manager's position is healthy but approaching liquidation zone

3. LPs need liquidity but managers aren't repaying voluntarily

Key Characteristics:

• Manager is not liquidated (they're still solvent)

• Manager receives their full net equity back

• Vault regains liquidity to serve LP withdrawals

• Only executed by designated ADL Manager (typically vault creator or protocol)

• Optional - can be permanently disabled when vault is created

ADL vs. Liquidation:

Feature	Liquidation	ADL
Trigger	Health < liquidation threshold	Health between liquidation & ADL threshold
Executed By	Anyone (permissionless)	ADL Manager only
Manager Outcome	Loses position + liquidation penalty	Receives full net equity
Purpose	Prevent bad debt	Free up liquidity
Vault Condition	Any utilization	High utilization (≥95%)
Profit for Executor	Yes (liquidation bonus)	No (break-even)

---

Why ADL Exists

The Liquidity Crunch Problem

Consider this scenario:

Vault State:
- Total Assets: $10M
- Borrowed by Managers: $9.5M (95% utilization)
- Idle Liquidity: $500K

LP Withdrawal Requests:
- Alice wants to withdraw $2M (will fail - insufficient liquidity)
- Bob wants to withdraw $1M (will fail - insufficient liquidity)
- LPs unable to withdraw

Manager Positions:
- All positions are healthy (can't be liquidated)
- Managers earning yield, no incentive to close
- But vault needs $2.5M more liquidity for LP withdrawals to succeed!

Without ADL: LPs cannot withdraw and are stuck waiting indefinitely for managers to voluntarily close positions.

With ADL: Vault creator can force-close positions (returning manager's equity) to free up liquidity so LP withdrawals can succeed.

ADL is LP Protection

ADL ensures that LPs can eventually get their capital back, even when:

• Managers are technically healthy

• Vault is fully utilized

• Withdrawals would otherwise fail

It prevents LPs from being held hostage by managers who won't close positions voluntarily.

---

How ADL Works

Eligibility Conditions

A position can be ADL'd only if ALL of these conditions are met:

1. High Vault Utilization

utilization = (totalAssets - idleLiquidity) / totalAssets

// Must be above ADL utilization threshold (typically 95%)
utilization >= adlUtilizationThreshold

Example:

Vault: $10M total, $500K idle
Utilization: 95% ✅ (above 95% threshold)

Vault: $10M total, $3M idle
Utilization: 70% ❌ (below 95% threshold, ADL blocked)

2. Position Health Below ADL Threshold

healthRatio = totalCollateralValue / debtValue

// Must be below ADL threshold (typically 120%)
// But above liquidation threshold (typically 110%)
healthRatio < adlThreshold && healthRatio >= liquidationThreshold

Example with Strategy Parameters:

Strategy Config:
- liquidationThreshold: 1.1 (110%)
- adlThreshold: 1.2 (120%)

Position:
- Collateral: $125K
- Debt: $110K
- Health: 113.6%

Result: 110% < 113.6% < 120% ✅ Can ADL

3. Position Still Has Positive Equity

netEquity = totalCollateralValue - debtValue

// Manager must have something to receive back
netEquity > 0

If netEquity ≤ 0: Position is underwater and should be liquidated instead.

ADL Parameters

Defined in the strategy contract:

struct StrategyParams {
    // ...other params...
    uint256 adlBuffer;               // e.g., 0.1e18 = 10%
    uint256 adlUtilizationThreshold; // e.g., 0.95e18 = 95%
}

// Derived value:
adlThreshold = liquidationThreshold + adlBuffer

Example:
liquidationThreshold = 1.1 (110%)
adlBuffer = 0.1 (10%)
→ adlThreshold = 1.2 (120%)

The ADL Zone:

Health Ratio Zones:

  200% ━━━━━━━━━━━━━━━━━━━━━━━ Extremely Healthy
       │
  150% ┃
       │  Healthy Zone
  120% ━━━━━━━━━━━━━━━━━━━━━━━ ADL Threshold
       │
       │  ADL Zone (can be ADL'd if utilization high)
  110% ━━━━━━━━━━━━━━━━━━━━━━━ Liquidation Threshold
       │
  100% ┃  Underwater Zone (should be liquidated)
       │
   90% ━━━━━━━━━━━━━━━━━━━━━━━ Severely Underwater

---

ADL Execution Flow

Step-by-Step Process

1. ADL Manager Identifies ADL Opportunity

// Check if position can be ADL'd
const { canADL, managerNetEquityUSD } = await strategy.evaluateADL(
  vaultAddress,
  managerAddress
);

if (canADL) {
  console.log(`Manager ${managerAddress} can be ADL'd`);
  console.log(`Net equity to return: $${managerNetEquityUSD / 1e18}`);
}

2. ADL Manager Prepares Executor

The ADL Manager needs an executor with a callback to handle position unwinding:

contract ADLExecutor is IFluxUnlockCallback {
    address public vault;
    address public immutable adlOwner;
    IERC20 public asset;
    IAsset public immutable baseAssetWrapper;

    function fluxUnlockCallback(bytes calldata data) external override {
        require(msg.sender == vault, "Only vault");

        // Decode ADL parameters
        (uint256 trueDebt, uint256 managerNetEquityUSD, bytes memory additionalData) =
            abi.decode(data, (uint256, uint256, bytes));

        uint256 totalPayment = trueDebt + managerNetEquityUSD;

        // 1. Withdraw manager's positions (transferred to us)
        _withdrawAllPositions();

        // 2. Liquidate positions to base asset
        _liquidateToBaseAsset();

        // 3. Deposit totalPayment to working capital
        vault.locked_depositToWrapper(
            baseAssetWrapper,
            WORKING_CAPITAL,
            totalPayment
        );

        // Vault will verify we deposited enough
    }
}

3. Execute ADL Transaction

// Only ADL Manager can call this
vault.executeADL(
    managerAddress,        // Manager to ADL
    additionalWrappers,    // Any extra wrappers manager may have used
    callbackData           // Custom data for executor
);

4. Vault Executes ADL

Inside the vault's executeADL function:

function executeADL(address manager, IAsset[] calldata additionalWrappers, bytes calldata data) {
    // 1. Access control
    require(msg.sender == adlManager, "Only ADL manager");
    require(!adlPermanentlyDisabled, "ADL disabled");

    // 2. Accrue interest
    _accrueInterest();

    // 3. Verify position is ADL-eligible
    (bool canADL, uint256 managerNetEquityUSD) = strategy.evaluateADL(address(this), manager);
    require(canADL, "Position not ADL-able");

    uint256 trueDebt = getManagerTrueDebt(manager);

    // 4. Transfer ALL manager's positions to ADL-er
    _transferAllPositions(manager, msg.sender, additionalWrappers);

    // 5. ADL-er unwinds positions via callback
    bytes memory callbackData = abi.encode(trueDebt, managerNetEquityUSD, data);
    _executeWithLock(msg.sender, callbackData);

    // 6. Verify ADL-er prepared enough payment (debt + net equity)
    uint256 adlerValueUSD = baseWrapper.getValue(msg.sender, WORKING_CAPITAL);
    uint256 debtValueUSD = oracle.getValueUSD(asset, trueDebt);
    uint256 totalRequiredUSD = debtValueUSD + managerNetEquityUSD;

    require(adlerValueUSD >= totalRequiredUSD, "Insufficient ADL preparation");

    // 7. Transfer ADL-er's working capital back to manager
    baseWrapper.ledgerTransferSubaccount(msg.sender, manager);

    // 8. Take debt payment from manager's working capital
    baseWrapper.withdraw(manager, WORKING_CAPITAL, address(this), trueDebt);

    // 9. Repay debt accounting
    _repay(principalToRemove);

    // 10. Cleanup manager's position
    delete managerPositions[manager];
    delete registeredWrappers[manager];

    // Manager now has netEquity in working capital, can withdraw
    emit ADLExecuted(manager, msg.sender, trueDebt, managerNetEquityUSD, totalRequiredUSD);
}

What Happens to Each Party

Manager (being ADL'd):

1. All positions closed

2. Debt repaid in full

3. Receives net equity in vault's base asset (in working capital)

4. Can withdraw net equity immediately

5. Loses future earning potential from position

6. No penalties or fees

ADL Manager (executor):

1. Receives all manager positions

2. Unwinds positions to base asset

3. Pays trueDebt + managerNetEquity back to vault

4. Ideally breaks even (no profit, no loss)

5. May incur gas costs and slippage

Vault / LPs:

1. Receives debt repayment

2. Gains liquidity

3. Can service LP withdrawals

4. Loses future interest from that manager

---

ADL Manager Role

What is an ADL Manager?

The ADL Manager is a designated address (typically the vault creator or protocol governance) that can execute ADL operations.

Key Responsibilities:

• Monitor vault utilization

• Identify ADL-eligible positions

• Execute ADL when needed to free liquidity

• Unwind positions with minimal slippage

• Return manager's equity fairly

Access Control:

// Only vault creator can set ADL manager
function setAdlManager(address newManager) external {
    require(msg.sender == vaultCreator, "Only creator");
    adlManager = newManager;
    emit ADLManagerUpdated(oldManager, newManager);
}

// Get current ADL manager
address public adlManager;

// Permanently disable ADL (irreversible)
function permanentlyDisableADL() external {
    require(msg.sender == vaultCreator, "Only creator");
    adlPermanentlyDisabled = true;
    adlManager = address(0);
    emit ADLPermanentlyDisabled();
}

ADL Manager Options

Option 1: Vault Creator as ADL Manager (Most Common)

// During vault creation
address vault = fluxFactory.createVault(...);

// Vault creator is initially set as ADL manager
// Can execute ADL when needed
vault.executeADL(unhealthyManager, wrappers, data);

Pros:

• Vault creator has incentive to maintain vault health

• Responsive to LP needs

• Can act quickly

Cons:

• Centralization risk

• Requires vault creator to actively monitor

• May have conflicts of interest

Option 2: Protocol Governance as ADL Manager

// Set governance multisig as ADL manager
vault.setAdlManager(governanceMultisig);

Pros:

• More decentralized

• Trustworthy for LPs

• Protocol-level oversight

Cons:

• Slower response time (multisig)

• May not prioritize individual vault needs

Option 3: Automated ADL Bot

// Set automated bot as ADL manager
ADLBot bot = new ADLBot(vault, strategy);
vault.setAdlManager(address(bot));

Pros:

• Fastest response

• 24/7 monitoring

• No human intervention needed

Cons:

• Bot can be exploited if not secure

• Requires funding for gas

• May execute suboptimally

Option 4: No ADL Manager (Disabled)

// Set to zero address to temporarily disable
vault.setAdlManager(address(0));

// Or permanently disable
vault.permanentlyDisableADL();

Use Cases:

• Vault creator wants pure market dynamics

• Immutable vaults prioritizing predictability

• Low-utilization vaults that don't need ADL

---

ADL in Different Strategy Types

Immutable Strategy

StrategyParams({
    minBondRatio: 0.25e18,           // 25%
    liquidationBuffer: 0.15e18,       // 15%
    adlBuffer: 0.1e18,                // 10% ✅ ADL enabled
    adlUtilizationThreshold: 0.95e18, // 95%
    // ...
});

// Thresholds:
liquidationThreshold = 1.0 + 0.25 - 0.15 = 1.1 (110%)
adlThreshold = 1.1 + 0.1 = 1.2 (120%)

// ADL zone: 110% < health < 120%

Characteristics:

• ADL parameters locked forever at deployment

• LPs know exact ADL trigger conditions

• Vault creator decides whether to set ADL manager

Mutable Strategy

// ADL parameters CANNOT be updated (even in mutable strategies)
// These are set at deployment and never change:
- adlBuffer
- adlUtilizationThreshold

// Only these can be updated:
- annualRate
- vaultCreatorFeeRate
- allowedAssets

Why ADL params are immutable:

• Changing ADL threshold could surprise managers

• LPs rely on predictable ADL protection

• Risk parameters should be stable

Flexible Margin Strategy

// ADL is DISABLED in flexible margin strategies
function evaluateADL(address vault, address manager)
    external view returns (bool canADL, uint256 managerNetEquityUSD)
{
    return (false, 0); // Always returns false
}

Why disabled?:

• Flexible margin vaults are typically single-user

• Manager = LP in most cases

• No need for forced deleveraging

• Manager can close position whenever they want

---

Use Cases and Examples

Example 1: High Utilization LP Withdrawal Crisis

Scenario:

Vault State:
- Total Assets: $50M
- Idle Liquidity: $2M (4% - very low!)
- Utilization: 96%

LP Withdrawal Attempts:
- LPs trying to withdraw $10M total
- All withdrawals failing due to insufficient liquidity
- LPs getting impatient

Manager Positions:
- Manager A: $15M borrowed, health 115% (in ADL zone!)
- Manager B: $20M borrowed, health 140% (too healthy for ADL)
- Manager C: $13M borrowed, health 118% (in ADL zone!)

ADL Manager Action:

// 1. Identify ADL targets
const targets = [];

for (const manager of allManagers) {
  const { canADL, netEquity } = await strategy.evaluateADL(vault, manager);
  if (canADL) {
    targets.push({ manager, netEquity });
  }
}

// Found: Manager A and Manager C

// 2. Calculate how much liquidity we need to serve LP withdrawals
const desiredLiquidity = 10_000_000e18;
const currentIdle = 2_000_000e18;
const needed = desiredLiquidity - currentIdle; // $8M

// 3. ADL just enough to cover withdrawals
let liquidityFreed = 0;
for (const target of targets) {
  if (liquidityFreed >= needed) break;

  await vault.executeADL(target.manager, [], "");
  liquidityFreed += target.debtRepaid;

  console.log(`ADL'd ${target.manager}, freed $${target.debtRepaid / 1e18}M`);
}

// Result:
// - Manager A ADL'd: $15M liquidity freed
// - Vault now has $17M idle
// - All LP withdrawals can be serviced
// - Manager A received their net equity back

Example 2: Preventing Bank Run

Scenario:

Market Event:
- Major protocol hack announced
- LPs rushing to withdraw from all vaults
- This vault getting hit hard

Before Event:
- Utilization: 75% (normal)

During Panic:
- $30M withdrawal requests in 1 hour
- Utilization jumps to 98%
- Idle liquidity: $1M
- Manager positions drifting toward ADL zone due to interest

ADL Manager Strategy:

// Proactive ADL to prevent cascading liquidations

// 1. Calculate target utilization
uint256 targetUtilization = 0.8e18; // 80% - safe level

// 2. Calculate liquidity needed
uint256 currentUtilization = vault.getCurrentUtilization();
uint256 liquidityToFree = calculateLiquidityNeeded(
    vault.totalAssets(),
    currentUtilization,
    targetUtilization
);

// 3. ADL positions starting with lowest health
address[] memory managers = getAllManagers();
sortByHealth(managers); // Ascending order

for (uint256 i = 0; i < managers.length; i++) {
    (bool canADL, uint256 netEquity) = strategy.evaluateADL(vault, managers[i]);

    if (canADL) {
        vault.executeADL(managers[i], [], "");

        // Check if we've freed enough
        if (vault.getCurrentUtilization() <= targetUtilization) {
            break; // Success!
        }
    }
}

Outcome:

• Vault stabilized at 80% utilization

• LPs can withdraw without queues

• Managers received their equity (no unfair liquidations)

• Vault creator maintains trust

Example 3: Gradual Deleveraging

Scenario: Vault creator wants to gradually reduce risk during uncertain market conditions.

class GradualDeleveragingADL {
  async execute() {
    const maxADLPerDay = 5; // At most 5 positions per day
    const targetUtilization = 0.85e18; // 85%

    while (true) {
      await sleep(24 * 60 * 60); // Wait 24 hours

      const currentUtil = await vault.getCurrentUtilization();

      if (currentUtil > targetUtilization) {
        // Find eligible positions
        const eligible = await findADLEligible();

        // ADL up to max per day
        const toADL = eligible.slice(0, maxADLPerDay);

        for (const manager of toADL) {
          await vault.executeADL(manager, [], "");
          console.log(`Gradual ADL: ${manager}`);
        }
      }
    }
  }
}

Benefits:

• Reduces vault risk over time

• Doesn't shock managers with sudden mass ADL

• Maintains adequate liquidity for LPs

• Spreads gas costs over time

---

ADL Implementation Guide

For Vault Creators

1. Decide on ADL Strategy

// Choose ADL parameters during strategy deployment
StrategyParams memory params = StrategyParams({
    // ...other params...
    adlBuffer: 0.1e18,                // 10% buffer above liquidation
    adlUtilizationThreshold: 0.95e18  // Trigger at 95% utilization
});

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

Parameter Selection:

Vault Type	adlBuffer	adlUtilizationThreshold	Reasoning
Conservative	0.15 (15%)	0.90 (90%)	Earlier ADL, more LP protection
Balanced	0.10 (10%)	0.95 (95%)	Standard config
Aggressive	0.05 (5%)	0.98 (98%)	Let managers maximize leverage

2. Set ADL Manager

// Option A: Set yourself as ADL manager
vault.setAdlManager(vaultCreator);

// Option B: Set governance
vault.setAdlManager(governanceMultisig);

// Option C: Deploy automated ADL bot
ADLBot bot = new ADLBot(vault, strategy);
vault.setAdlManager(address(bot));

// Option D: Disable ADL
vault.setAdlManager(address(0));

// Option E: Permanently disable (irreversible!)
vault.permanentlyDisableADL();

3. Monitor Vault Health

// Monitoring dashboard
async function monitorVaultADL() {
  const utilization = await vault.getCurrentUtilization();
  const threshold = await strategy.adlUtilizationThreshold();

  console.log(`Utilization: ${utilization / 1e16}%`);
  console.log(`ADL Threshold: ${threshold / 1e16}%`);

  if (utilization >= threshold) {
    console.warn("⚠️  High utilization - check for ADL opportunities");

    // Scan all managers
    const managers = await getAllManagers();
    for (const manager of managers) {
      const { canADL, netEquity } = await strategy.evaluateADL(vault, manager);

      if (canADL) {
        console.log(`🎯 ADL Target: ${manager}`);
        console.log(`   Net Equity: $${netEquity / 1e18}`);
        console.log(`   Health: ${await getHealth(manager) / 1e16}%`);
      }
    }
  }
}

// Run every hour
setInterval(monitorVaultADL, 60 * 60 * 1000);

4. Execute ADL When Needed

async function executeADLIfNeeded() {
  const targetLiquidity = await calculateTargetLiquidity(); // Based on typical LP needs
  const idleLiquidity = await vault.getIdleLiquidity();

  if (idleLiquidity < targetLiquidity) {
    const deficit = targetLiquidity - idleLiquidity;
    console.log(`Need $${deficit / 1e18} more liquidity for LP withdrawals`);

    // Find ADL candidates
    const candidates = await findADLCandidates();

    // Sort by health (lowest first - closest to liquidation)
    candidates.sort((a, b) => a.health - b.health);

    // ADL until we have enough liquidity
    let freed = 0;
    for (const candidate of candidates) {
      if (freed >= deficit) break;

      await vault.executeADL(candidate.manager, [], "");
      freed += candidate.debt;

      console.log(`✅ ADL'd ${candidate.manager}`);
    }
  }
}

For ADL Managers (Executors)

Building an ADL Executor

contract ProductionADLExecutor is IFluxUnlockCallback {
    IFluxVault public immutable vault;
    address public immutable adlOwner;
    IAsset public immutable baseAssetWrapper;
    IERC20 public immutable baseAsset;

    // DEX router for unwinding positions
    ISwapRouter public immutable swapRouter;

    constructor(
        address _vault,
        address _adlOwner,
        address _baseAssetWrapper,
        address _swapRouter
    ) {
        vault = IFluxVault(_vault);
        adlOwner = _adlOwner;
        baseAssetWrapper = IAsset(_baseAssetWrapper);
        baseAsset = IERC20(vault.asset());
        swapRouter = ISwapRouter(_swapRouter);

        baseAsset.approve(_vault, type(uint256).max);
    }

    function fluxUnlockCallback(bytes calldata data) external override {
        require(msg.sender == address(vault), "Only vault");

        // Decode ADL data
        (uint256 trueDebt, uint256 managerNetEquityUSD, ) =
            abi.decode(data, (uint256, uint256, bytes));

        uint256 totalPaymentNeeded = trueDebt + managerNetEquityUSD;

        // Step 1: Withdraw all positions we received
        uint256 bondBalance = vault.getBondBalance(adlOwner);
        if (bondBalance > 0) {
            vault.locked_withdrawBond(bondBalance);
        }

        uint256 workingCapital = vault.getWorkingCapital(adlOwner);
        if (workingCapital > 0) {
            vault.locked_withdrawFromWrapper(
                baseAssetWrapper,
                WORKING_CAPITAL,
                workingCapital
            );
        }

        // Step 2: Unwind all other positions to base asset
        address[] memory wrappers = vault.registeredWrappers(adlOwner);
        uint256 totalUnwound = 0;

        for (uint256 i = 0; i < wrappers.length; i++) {
            if (wrappers[i] == address(baseAssetWrapper)) continue;

            // Get all position IDs for this wrapper
            bytes32[] memory positionIds = getPositionIds(adlOwner, wrappers[i]);

            for (uint256 j = 0; j < positionIds.length; j++) {
                uint256 amount = IAsset(wrappers[i]).getValue(
                    address(vault),
                    adlOwner,
                    positionIds[j]
                );

                if (amount > 0) {
                    // Withdraw position
                    vault.locked_withdrawFromWrapper(
                        IAsset(wrappers[i]),
                        positionIds[j],
                        type(uint256).max
                    );

                    // Swap to base asset
                    uint256 baseReceived = _swapToBase(wrappers[i], amount);
                    totalUnwound += baseReceived;
                }
            }
        }

        // Step 3: Verify we have enough
        uint256 totalBase = bondBalance + workingCapital + totalUnwound;
        require(totalBase >= totalPaymentNeeded, "Insufficient unwound value");

        // Step 4: Deposit payment to working capital
        vault.locked_depositToWrapper(
            baseAssetWrapper,
            WORKING_CAPITAL,
            totalPaymentNeeded
        );

        // Any excess remains with ADL-er (compensation for gas/slippage)
    }

    function _swapToBase(address wrapper, uint256 amount) internal returns (uint256) {
        // Get underlying token from wrapper
        address token = IAsset(wrapper).underlyingAsset();

        // Approve router
        IERC20(token).approve(address(swapRouter), amount);

        // Swap with slippage protection
        uint256 minOut = calculateMinOut(token, address(baseAsset), amount);

        return swapRouter.exactInputSingle(
            ISwapRouter.ExactInputSingleParams({
                tokenIn: token,
                tokenOut: address(baseAsset),
                fee: 3000,
                recipient: address(this),
                deadline: block.timestamp,
                amountIn: amount,
                amountOutMinimum: minOut,
                sqrtPriceLimitX96: 0
            })
        );
    }
}

ADL Monitoring Bot

class ADLMonitoringBot {
  async run() {
    while (true) {
      try {
        // 1. Check vault utilization
        const utilization = await this.vault.getCurrentUtilization();
        const threshold = await this.strategy.adlUtilizationThreshold();

        if (utilization >= threshold) {
          // 2. Scan for ADL opportunities
          const opportunities = await this.findADLOpportunities();

          // 3. Prioritize by urgency
          opportunities.sort((a, b) => {
            // Lower health = more urgent
            return a.health - b.health;
          });

          // 4. Execute most urgent ADLs
          for (const opp of opportunities) {
            // Check if still needed
            const currentUtil = await this.vault.getCurrentUtilization();
            if (currentUtil < threshold * 0.95) {
              // Utilization back to safe level
              break;
            }

            // Execute ADL
            await this.executeADL(opp.manager);

            // Wait between ADLs to avoid gas spikes
            await sleep(60000); // 1 minute
          }
        }

        // Sleep before next check
        await sleep(300000); // 5 minutes
      } catch (error) {
        console.error("ADL bot error:", error);
        await sleep(60000); // 1 minute before retry
      }
    }
  }

  async findADLOpportunities() {
    const managers = await this.getAllManagers();
    const opportunities = [];

    for (const manager of managers) {
      const { canADL, managerNetEquityUSD } =
        await this.strategy.evaluateADL(this.vault.address, manager);

      if (canADL) {
        const health = await this.lens.getManagerHealth(
          this.vault.address,
          manager
        );
        const debt = await this.vault.getManagerTrueDebt(manager);

        opportunities.push({
          manager,
          health,
          debt,
          netEquity: managerNetEquityUSD,
        });
      }
    }

    return opportunities;
  }

  async executeADL(manager: string) {
    console.log(`Executing ADL on ${manager}`);

    // Get registered wrappers
    const wrappers = await this.vault.registeredWrappers(manager);

    // Execute ADL transaction
    const tx = await this.vault.executeADL(
      manager,
      wrappers, // Pass all known wrappers
      "0x" // No additional data
    );

    const receipt = await tx.wait();
    console.log(`ADL executed: ${receipt.transactionHash}`);
  }
}

// Start bot
const bot = new ADLMonitoringBot(vault, strategy, lens);
bot.run();

---

ADL Best Practices

For Vault Creators

Do:

• Set ADL parameters appropriate for your vault's risk profile

• Monitor utilization regularly

• Communicate ADL policy clearly to LPs and managers

• Execute ADL fairly (lowest health first)

• Document when and why you'll use ADL

Don't:

• ADL managers to punish them (unfair)

• ADL when utilization is healthy (unnecessary)

• Change ADL manager frequently (undermines trust)

• Execute ADL with excessive slippage (hurts manager)

• Forget to fund your ADL executor for gas

For Managers

Do:

• Understand the vault's ADL parameters before depositing

• Monitor your health ratio to stay out of ADL zone

• Keep vault utilization in mind

• Accept that ADL is fair (you get full equity back)

• Have a plan for receiving net equity after ADL

Don't:

• Assume you'll never be ADL'd

• Let health drift into ADL zone during high utilization

• Fight or complain about fair ADL execution

• Borrow from vaults with unfair ADL policies

For LPs

Do:

• Understand the vault's ADL protection

• Check if vault has an ADL manager

• Verify ADL parameters match your risk tolerance

• Appreciate ADL as liquidity protection

Don't:

• Deposit in vaults with ADL disabled if you need withdrawal flexibility

• Expect instant withdrawals during extreme utilization

• Assume ADL will always save you (bad debt can still happen)

---

Comparison: ADL vs. Other Mechanisms

ADL vs. Liquidation

Feature	ADL	Liquidation
Trigger	Health in ADL zone + high utilization	Health below liquidation threshold
Executor	Designated ADL manager	Anyone (permissionless)
Manager Outcome	Receives full net equity	May receive net equity minus penalty
Executor Profit	Break-even (no profit)	Liquidation bonus (0-20%)
Purpose	Free liquidity	Prevent bad debt
Vault Condition	High utilization required	Any utilization

When to use each:

• ADL: Vault needs liquidity, manager is healthy but risky

• Liquidation: Manager's position is truly at risk of bad debt

ADL vs. Forced Withdrawal

Some protocols have "forced withdrawal" where LP can liquidate a manager. Flux separates these:

Feature	Flux ADL	Forced Withdrawal
Who Executes	Vault-level ADL manager	Individual LP
Coordination	Centralized, efficient	Decentralized, chaotic
Fairness	All LPs benefit equally	First-mover advantage
Gas Costs	Single executor	Every LP pays
Slippage	Optimized by ADL manager	May be rushed

Flux's approach is more efficient because:

• Single ADL manager can optimize unwinding

• No race condition between LPs

• All LPs benefit proportionally from freed liquidity

• Lower total gas costs

ADL vs. Interest Rate Adjustments

Feature	ADL	Dynamic Interest Rates
Time to Effect	Immediate	Gradual
Mechanism	Force close positions	Incentivize voluntary close
Manager Choice	None	Yes
Complexity	Simple	Complex (IRM curves)
Emergency Response	Effective	Slow

Best practice: Use both

• Normal times: Adjust rates to encourage borrowing/repayment

• Emergency: Use ADL to quickly free liquidity

---

Technical Reference

Events

// Emitted when ADL is executed
event ADLExecuted(
    address indexed manager,
    address indexed adlManager,
    uint256 trueDebt,
    uint256 managerNetEquityUSD,
    uint256 totalPayment
);

// Emitted when ADL manager is updated
event ADLManagerUpdated(
    address indexed oldManager,
    address indexed newManager
);

// Emitted when ADL is permanently disabled
event ADLPermanentlyDisabled();

Errors

// ADL-specific errors
error OnlyADLManager();          // Only ADL manager can call
error PositionNotADLable();      // Position doesn't meet ADL criteria
error ADLPermanentlyDisabled();  // ADL has been disabled forever
error InsufficientADLPreparation(uint256 prepared, uint256 required);

View Functions

// Check if position can be ADL'd
function evaluateADL(address vault, address manager)
    external view
    returns (bool canADL, uint256 managerNetEquityUSD);

// Get ADL threshold
function adlThreshold() external view returns (uint64);

// Get ADL utilization threshold
function adlUtilizationThreshold() external view returns (uint64);

// Get current ADL manager
function adlManager() external view returns (address);

// Check if ADL is permanently disabled
function adlPermanentlyDisabled() external view returns (bool);

---

Summary

Auto-Deleveraging (ADL) is Flux's liquidity protection mechanism that allows vaults to force-close healthy-but-risky positions during high utilization.

Key Takeaways:

1. Purpose: Free up liquidity for LP withdrawals when vault is highly utilized

2. Fair to Managers: They receive their full net equity back (no penalties)

3. Controlled: Only designated ADL manager can execute

4. Conditional: Requires both high utilization AND position in ADL zone

5. Optional: Vault creators can disable or customize ADL parameters

ADL protects LPs from being unable to withdraw during high utilization periods, while treating managers fairly by returning their full equity.