Capital-Free Liquidations

Learn how to execute profitable liquidations without upfront capital using Flux's locked_borrow() mechanism.

Overview

Traditional liquidations require:

1. Capital to purchase liquidatable debt

2. Assets to swap for repayment

3. Flash loans (complex and risky)

Flux enables capital-free liquidations through the locked_borrow() callback, allowing liquidators to:

• Borrow vault assets temporarily

• Liquidate manager positions

• Repay vault with acquired assets

• Keep profit without any upfront capital

---

How It Works

The locked_borrow() Flow

1. Call vault.liquidate(manager)
2. Vault calls liquidator.onLockedBorrow() callback
3. Inside callback:
   a. Receive manager's collateral assets
   b. Swap assets to vault's base asset
   c. Return enough to cover debt
4. Vault verifies repayment
5. Liquidator keeps the profit

Code Example

contract CapitalFreeLiquidator {
    function liquidateWithoutCapital(
        address vault,
        address manager
    ) external {
        IFluxVault(vault).liquidate(manager);
        // Profit automatically received after callback completes
    }

    function onLockedBorrow(
        uint256 debt,
        bytes calldata data
    ) external returns (uint256 repayAmount) {
        // Decode manager address
        address manager = abi.decode(data, (address));

        // Get manager's assets (transferred to us by vault)
        address[] memory assets = getManagerAssets(manager);

        uint256 totalBase = 0;

        // Swap all assets to base asset
        for (uint i = 0; i < assets.length; i++) {
            uint256 balance = IERC20(assets[i]).balanceOf(address(this));
            uint256 baseReceived = swapToBase(assets[i], balance);
            totalBase += baseReceived;
        }

        // Calculate repayment (strategy-specific)
        repayAmount = calculateRepayment(debt, manager);

        // Approve vault to take repayment
        IERC20(baseAsset).approve(msg.sender, repayAmount);

        // Profit = totalBase - repayAmount
        uint256 profit = totalBase - repayAmount;

        return repayAmount;
    }
}

---

Detailed Implementation

Step 1: Monitor for Liquidatable Positions

function findLiquidatablePositions(address vault)
    public
    view
    returns (address[] memory)
{
    address[] memory allManagers = getVaultManagers(vault);
    address[] memory liquidatable = new address[](allManagers.length);
    uint256 count = 0;

    for (uint i = 0; i < allManagers.length; i++) {
        (, bool canLiquidate) = IFluxVault(vault).evaluateLiquidation(
            allManagers[i]
        );

        if (canLiquidate) {
            liquidatable[count] = allManagers[i];
            count++;
        }
    }

    // Resize array
    assembly { mstore(liquidatable, count) }

    return liquidatable;
}

Step 2: Calculate Expected Profit

function estimateLiquidationProfit(
    address vault,
    address manager
) public view returns (uint256 estimatedProfit, bool isProfitable) {
    IFluxVault v = IFluxVault(vault);

    // Get manager's position value
    uint256 positionValue = v.getPositionValue(manager);

    // Get debt
    uint256 debt = v.getDebt(manager);

    // Get liquidation payment
    (uint256 minPayment,) = v.evaluateLiquidation(manager);

    // Estimate slippage from swapping assets (5%)
    uint256 estimatedSlippage = 5;
    uint256 expectedBase = positionValue * (100 - estimatedSlippage) / 100;

    // Profit = expected base - payment required
    if (expectedBase > minPayment) {
        estimatedProfit = expectedBase - minPayment;
        isProfitable = true;
    } else {
        estimatedProfit = 0;
        isProfitable = false;
    }

    return (estimatedProfit, isProfitable);
}

Step 3: Execute Liquidation

function executeLiquidation(address vault, address manager) external {
    // 1. Verify liquidatable and profitable
    (uint256 profit, bool profitable) = estimateLiquidationProfit(vault, manager);
    require(profitable, "Not profitable");

    // 2. Execute liquidation
    try IFluxVault(vault).liquidate(manager) {
        // Success - profit received
        emit LiquidationSuccess(vault, manager, profit);
    } catch Error(string memory reason) {
        // Failed - log reason
        emit LiquidationFailed(vault, manager, reason);
    }
}

Step 4: Handle Callback

function onLockedBorrow(
    uint256 debt,
    bytes calldata data
) external override returns (uint256) {
    // Decode data
    (address manager, address vault) = abi.decode(data, (address, address));

    // Get manager's assets
    IAsset[] memory assets = getPositionAssets(vault, manager);

    // Swap all to base
    uint256 totalBase = liquidateAssets(assets, vault);

    // Calculate required payment
    (uint256 minPayment,) = IFluxVault(vault).evaluateLiquidation(manager);

    // Ensure we have enough
    require(totalBase >= minPayment, "Insufficient liquidity");

    // Approve repayment
    IERC20(IFluxVault(vault).asset()).approve(vault, minPayment);

    // Keep profit
    uint256 profit = totalBase - minPayment;

    return minPayment;
}

---

DEX Integration

Swap Assets Efficiently

function swapToBase(
    address assetIn,
    uint256 amountIn
) internal returns (uint256 amountOut) {
    // Try multiple DEXes for best price
    uint256 uniswapQuote = getUniswapQuote(assetIn, baseAsset, amountIn);
    uint256 sushiQuote = getSushiswapQuote(assetIn, baseAsset, amountIn);
    uint256 curveQuote = getCurveQuote(assetIn, baseAsset, amountIn);

    // Use best quote
    if (uniswapQuote > sushiQuote && uniswapQuote > curveQuote) {
        return swapOnUniswap(assetIn, baseAsset, amountIn);
    } else if (sushiQuote > curveQuote) {
        return swapOnSushiswap(assetIn, baseAsset, amountIn);
    } else {
        return swapOnCurve(assetIn, baseAsset, amountIn);
    }
}

Multi-Hop Swaps

function swapWithBestRoute(
    address tokenIn,
    address tokenOut,
    uint256 amountIn
) internal returns (uint256 amountOut) {
    // Direct swap
    uint256 directQuote = getDirectQuote(tokenIn, tokenOut, amountIn);

    // Via WETH
    uint256 viaWETHQuote = getQuoteViaWETH(tokenIn, tokenOut, amountIn);

    // Via USDC
    uint256 viaUSDCQuote = getQuoteViaUSDC(tokenIn, tokenOut, amountIn);

    // Use best route
    if (directQuote >= viaWETHQuote && directQuote >= viaUSDCQuote) {
        return executeDirectSwap(tokenIn, tokenOut, amountIn);
    } else if (viaWETHQuote >= viaUSDCQuote) {
        return executeSwapViaWETH(tokenIn, tokenOut, amountIn);
    } else {
        return executeSwapViaUSDC(tokenIn, tokenOut, amountIn);
    }
}

---

Gas Optimization

// Batch liquidations in single transaction
function batchLiquidate(
    address vault,
    address[] calldata managers
) external {
    for (uint i = 0; i < managers.length; i++) {
        try IFluxVault(vault).liquidate(managers[i]) {
            // Continue on success
        } catch {
            // Continue even if one fails
        }
    }
}

---

Profit Calculation

struct LiquidationProfit {
    uint256 positionValue;      // Value of manager's assets
    uint256 debt;               // Manager's debt
    uint256 minPayment;         // Required payment
    uint256 swapSlippage;       // Estimated slippage
    uint256 gasEstimate;        // Gas cost estimate
    uint256 netProfit;          // Final profit
    bool worthExecuting;        // Profitable after gas?
}

function calculateDetailedProfit(
    address vault,
    address manager,
    uint256 gasPrice
) public view returns (LiquidationProfit memory) {
    IFluxVault v = IFluxVault(vault);

    LiquidationProfit memory profit;

    profit.positionValue = v.getPositionValue(manager);
    profit.debt = v.getDebt(manager);
    (profit.minPayment,) = v.evaluateLiquidation(manager);

    // Estimate slippage (5%)
    profit.swapSlippage = profit.positionValue * 5 / 100;

    // Expected base after swaps
    uint256 expectedBase = profit.positionValue - profit.swapSlippage;

    // Gross profit
    uint256 grossProfit = expectedBase > profit.minPayment
        ? expectedBase - profit.minPayment
        : 0;

    // Gas cost (estimate 300k gas)
    profit.gasEstimate = 300000 * gasPrice;

    // Net profit
    profit.netProfit = grossProfit > profit.gasEstimate
        ? grossProfit - profit.gasEstimate
        : 0;

    profit.worthExecuting = profit.netProfit > 0;

    return profit;
}

---

Error Handling

function safeLiquidate(address vault, address manager) external {
    try IFluxVault(vault).liquidate(manager) {
        emit Success(vault, manager);
    } catch Error(string memory reason) {
        if (keccak256(bytes(reason)) == keccak256("Not liquidatable")) {
            // Position became healthy - normal
        } else if (keccak256(bytes(reason)) == keccak256("Insufficient liquidity")) {
            // Could not swap assets
            emit SwapFailed(vault, manager);
        } else {
            // Unknown error
            emit UnknownError(vault, manager, reason);
        }
    }
}

---

Related Documentation

• Profit Optimization - Maximizing liquidation profits

• Liquidator Bot Guide - Full implementation guide

• Liquidation Concepts - How liquidations work

• Advanced Liquidation Strategies - Advanced techniques