Profit Optimization

Maximize your liquidation profits through optimal routing, timing, and execution strategies.

Overview

Successful liquidation requires more than just finding liquidatable positions—you must optimize every aspect of the execution to maximize profitability.

Key optimization areas:

1. DEX routing - Best prices for asset swaps

2. Gas optimization - Minimize execution costs

3. Timing - Execute at optimal moments

4. Position selection - Choose most profitable liquidations

5. MEV protection - Avoid being frontrun

---

DEX Routing Optimization

Multi-DEX Aggregation

function getBestQuote(
    address tokenIn,
    address tokenOut,
    uint256 amountIn
) public view returns (
    address bestDex,
    uint256 bestAmountOut
) {
    // Check Uniswap V2
    uint256 uniV2Quote = quoters.uniswapV2.getAmountOut(
        amountIn,
        tokenIn,
        tokenOut
    );

    // Check Uniswap V3
    uint256 uniV3Quote = quoters.uniswapV3.quoteExactInputSingle(
        tokenIn,
        tokenOut,
        3000,  // 0.3% fee tier
        amountIn,
        0
    );

    // Check Sushiswap
    uint256 sushiQuote = quoters.sushiswap.getAmountOut(
        amountIn,
        tokenIn,
        tokenOut
    );

    // Check Curve (for stablecoins)
    uint256 curveQuote = quoters.curve.get_dy(
        tokenIn,
        tokenOut,
        amountIn
    );

    // Return best
    if (uniV2Quote > uniV3Quote && uniV2Quote > sushiQuote && uniV2Quote > curveQuote) {
        return (address(quoters.uniswapV2), uniV2Quote);
    } else if (uniV3Quote > sushiQuote && uniV3Quote > curveQuote) {
        return (address(quoters.uniswapV3), uniV3Quote);
    } else if (sushiQuote > curveQuote) {
        return (address(quoters.sushiswap), sushiQuote);
    } else {
        return (address(quoters.curve), curveQuote);
    }
}

Split Orders

For large liquidations, split across multiple DEXes:

function splitOrderOptimally(
    address tokenIn,
    address tokenOut,
    uint256 totalAmount
) public view returns (
    uint256 amountViaUni,
    uint256 amountViaSushi,
    uint256 totalOut
) {
    // Start with 100% on best DEX
    // Incrementally test splits
    uint256 bestSplit = 0;
    uint256 bestOutput = 0;

    for (uint split = 0; split <= 100; split += 10) {
        uint256 uniAmount = totalAmount * split / 100;
        uint256 sushiAmount = totalAmount - uniAmount;

        uint256 uniOut = getQuote(uniswap, tokenIn, tokenOut, uniAmount);
        uint256 sushiOut = getQuote(sushiswap, tokenIn, tokenOut, sushiAmount);

        uint256 totalOutput = uniOut + sushiOut;

        if (totalOutput > bestOutput) {
            bestOutput = totalOutput;
            bestSplit = split;
        }
    }

    amountViaUni = totalAmount * bestSplit / 100;
    amountViaSushi = totalAmount - amountViaUni;
    totalOut = bestOutput;
}

---

Gas Optimization

Batch Processing

// Process multiple liquidations in one transaction
function batchLiquidate(
    address[] calldata vaults,
    address[] calldata managers
) external {
    require(vaults.length == managers.length, "Length mismatch");

    for (uint i = 0; i < vaults.length; i++) {
        try IFluxVault(vaults[i]).liquidate(managers[i]) {
            // Success
        } catch {
            // Continue even if one fails
            continue;
        }
    }
}

Optimize Approvals

// Don't re-approve if already approved
mapping(address => mapping(address => bool)) public approvals;

function ensureApproval(address token, address spender, uint256 amount) internal {
    if (!approvals[token][spender]) {
        IERC20(token).approve(spender, type(uint256).max);
        approvals[token][spender] = true;
    }
}

Use Efficient Swaps

// Direct swap path when possible
function swapDirect(
    address tokenIn,
    address tokenOut,
    uint256 amountIn
) internal returns (uint256) {
    address[] memory path = new address[](2);
    path[0] = tokenIn;
    path[1] = tokenOut;

    return router.swapExactTokensForTokens(
        amountIn,
        0,
        path,
        address(this),
        block.timestamp
    )[1];
}

---

Timing Optimization

Gas Price Monitoring

function shouldExecuteNow(
    uint256 estimatedProfit,
    uint256 currentGasPrice,
    uint256 maxGasPrice
) public pure returns (bool) {
    // Don't execute if gas too high
    if (currentGasPrice > maxGasPrice) {
        return false;
    }

    // Calculate gas cost
    uint256 gasUnits = 300000;  // Estimated gas
    uint256 gasCost = gasUnits * currentGasPrice;

    // Only execute if profit > 2x gas cost
    return estimatedProfit > gasCost * 2;
}

Priority Fee Calculation

function calculateOptimalPriorityFee(
    uint256 estimatedProfit
) public view returns (uint256 priorityFee) {
    // Use up to 20% of profit as priority fee
    uint256 maxPriorityFee = estimatedProfit * 20 / 100 / 300000;  // Per gas

    // Get current base fee
    uint256 baseFee = block.basefee;

    // Get network priority fee
    uint256 networkPriorityFee = getMedianPriorityFee();

    // Use higher of network or calculated, capped at max
    priorityFee = min(max(networkPriorityFee, baseFee / 10), maxPriorityFee);

    return priorityFee;
}

---

Position Selection

Profit Scoring

struct LiquidationScore {
    address vault;
    address manager;
    uint256 estimatedProfit;
    uint256 gasEstimate;
    uint256 netProfit;
    uint256 slippageRisk;  // 0-100
    uint256 score;         // Combined score
}

function scoreLiquidation(
    address vault,
    address manager,
    uint256 gasPrice
) public view returns (LiquidationScore memory) {
    LiquidationScore memory score;

    score.vault = vault;
    score.manager = manager;

    // Calculate profit
    (uint256 profit,) = estimateLiquidationProfit(vault, manager);
    score.estimatedProfit = profit;

    // Estimate gas
    score.gasEstimate = 300000 * gasPrice;

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

    // Assess slippage risk
    score.slippageRisk = assessSlippageRisk(vault, manager);

    // Calculate combined score
    // Higher net profit = higher score
    // Higher slippage risk = lower score
    score.score = score.netProfit * (100 - score.slippageRisk) / 100;

    return score;
}

function prioritizeLiquidations(
    LiquidationScore[] memory opportunities
) public pure returns (LiquidationScore[] memory) {
    // Sort by score (descending)
    // Execute highest score first
    // ... sorting implementation
    return opportunities;
}

---

MEV Protection

Flashbots Integration

// Use Flashbots to avoid being frontrun
function liquidateViaFlashbots(
    address vault,
    address manager
) external {
    // Build liquidation transaction
    bytes memory txData = abi.encodeWithSelector(
        IFluxVault.liquidate.selector,
        manager
    );

    // Submit via Flashbots RPC
    // This keeps transaction private until included
    submitToFlashbots(vault, txData);
}

Private Mempool

// Use private RPCs to avoid public mempool
function privateLiquidate(
    address vault,
    address manager
) external {
    // Configure transaction with high priority
    // Submit via private RPC (Eden, Flashbots, etc.)
    // Avoid public mempool exposure
}

---

Advanced Strategies

Just-In-Time Liquidation

Wait until last moment before liquidation:

function calculateOptimalLiquidationTime(
    address vault,
    address manager
) public view returns (uint256 optimalTime) {
    // Get current health
    uint256 currentHealth = getHealthRatio(vault, manager);

    // Get liquidation threshold
    uint256 threshold = getLiquidationThreshold(vault);

    // Get debt growth rate
    uint256 debtGrowthRate = getDebtGrowthRate(vault, manager);

    // Calculate time until liquidatable
    // Wait until just before threshold for maximum discount
    // But with safety buffer

    uint256 safetyBuffer = 0.05e18;  // 5%
    uint256 targetHealth = threshold + safetyBuffer;

    // Time calculation...
    optimalTime = block.timestamp + calculateTimeToHealth(
        currentHealth,
        targetHealth,
        debtGrowthRate
    );
}

Partial Liquidations

Liquidate incrementally for better prices:

function partialLiquidate(
    address vault,
    address manager,
    uint256 percentage
) external {
    // Liquidate only portion of position
    // Better prices on smaller swaps
    // Can liquidate again if still unhealthy
}

---

Monitoring and Analytics

Track Performance

struct LiquidationMetrics {
    uint256 totalLiquidations;
    uint256 totalProfit;
    uint256 totalGasSpent;
    uint256 averageProfit;
    uint256 successRate;
    uint256 bestProfit;
    uint256 worstProfit;
}

mapping(address => LiquidationMetrics) public botMetrics;

function recordLiquidation(
    uint256 profit,
    uint256 gasSpent,
    bool success
) internal {
    LiquidationMetrics storage metrics = botMetrics[msg.sender];

    if (success) {
        metrics.totalLiquidations++;
        metrics.totalProfit += profit;
        metrics.totalGasSpent += gasSpent;

        if (profit > metrics.bestProfit) {
            metrics.bestProfit = profit;
        }
    }

    // Update average
    metrics.averageProfit = metrics.totalProfit / metrics.totalLiquidations;

    // Update success rate
    metrics.successRate = metrics.totalLiquidations * 100 / totalAttempts;
}

---

Best Practices

1. Monitor multiple vaults - More opportunities

2. Use DEX aggregators - Better prices

3. Optimize gas - Higher net profit

4. Time execution - Wait for good gas prices

5. Protect from MEV - Use Flashbots or private RPCs

6. Track metrics - Improve over time

7. Have backup plans - Multiple DEX options

8. Test thoroughly - Simulate before executing

---

Example Bot Architecture

contract OptimizedLiquidationBot {
    // Configuration
    uint256 public minProfit;
    uint256 public maxGasPrice;
    bool public useFlashbots;

    function execute() external {
        // 1. Find opportunities
        LiquidationScore[] memory opportunities = findOpportunities();

        // 2. Score and prioritize
        opportunities = prioritizeLiquidations(opportunities);

        // 3. Check gas price
        if (tx.gasprice > maxGasPrice) return;

        // 4. Execute best opportunities
        for (uint i = 0; i < opportunities.length && i < 3; i++) {
            if (opportunities[i].netProfit >= minProfit) {
                executeLiquidation(opportunities[i]);
            }
        }
    }

    function executeLiquidation(LiquidationScore memory opp) internal {
        if (useFlashbots) {
            liquidateViaFlashbots(opp.vault, opp.manager);
        } else {
            IFluxVault(opp.vault).liquidate(opp.manager);
        }
    }
}

---

Related Documentation

• Capital-Free Liquidations

• Liquidator Bot Guide

• Advanced Liquidation Strategies