Advanced Liquidation Strategies

This guide covers advanced techniques for liquidating positions in Flux Protocol, including capital-free liquidations, leveraged liquidations, and complex multi-step strategies.

Overview

During liquidation, the liquidator receives a callback where they have access to all locked_* operations, just like a manager. This enables powerful strategies:

1. Capital-Free Liquidation - Use seized collateral to pay for liquidation

2. Leveraged Liquidation - Borrow from the vault to liquidate

3. Flash Liquidation - Borrow, liquidate, repay in single transaction

4. Cross-Protocol Arbitrage - Liquidate via external DEXs for profit

5. Recursive Liquidation - Open position against vault to liquidate another manager

Key Insight: Liquidators are temporary managers during the callback. They can borrow, deposit, withdraw, and interact with wrappers just like regular managers.

---

Available Operations During Liquidation

During the liquidation callback, liquidators have access to:

interface ILiquidatorOperations {
    // Capital operations
    function locked_borrow(uint256 amount) external;
    function locked_repay(uint256 amount) external;

    // Bond operations
    function locked_depositBond(uint256 amount) external;
    function locked_withdrawBond(uint256 amount) external;

    // Wrapper operations
    function locked_registerWrapper(address wrapper) external;
    function locked_deregisterWrapper(address wrapper) external;
    function locked_depositToWrapper(IAsset wrapper, bytes32 positionId, uint256 amount) external;
    function locked_withdrawFromWrapper(IAsset wrapper, bytes32 positionId, uint256 amount) external;
    function locked_claimFromWrapper(IAsset wrapper, bytes32 positionId, uint256 amountOrTokenId) external;
    function locked_interactWithWrapper(address wrapper, bytes calldata data) external;

    // Working capital management
    function locked_moveFunds(bytes32 fromPositionId, bytes32 toPositionId, uint256 amount) external;
}

What You Receive:

• All of manager's positions (bond + wrappers + working capital)

• Lock on vault (atomic execution)

• Ability to use vault operations

What You Must Return:

• Minimum payment in your working capital (base asset wrapper)

• Vault verifies this after callback completes

---

Strategy 1: Capital-Free Liquidation (Basic)

Use the seized collateral itself to pay for the liquidation.

Concept

1. Vault transfers manager's positions to liquidator
2. Liquidator withdraws working capital
3. Liquidator withdraws bond
4. Liquidator deposits minimum payment back to working capital
5. Vault takes payment, liquidator keeps excess as profit

Implementation

contract CapitalFreeLiquidator is IFluxUnlockCallback {
    IFluxVault public immutable vault;
    IAsset public immutable baseWrapper;
    address public immutable owner;

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

        // Decode liquidation params
        (uint256 minPayment, uint256 trueDebt, ) =
            abi.decode(data, (uint256, uint256, bytes));

        // Step 1: Withdraw seized working capital
        uint256 workingCapital = vault.getWorkingCapital(owner);
        if (workingCapital > 0) {
            vault.locked_withdrawFromWrapper(
                baseWrapper,
                WORKING_CAPITAL,
                workingCapital
            );
        }

        // Step 2: Withdraw seized bond
        uint256 bondBalance = vault.getBondBalance(owner);
        if (bondBalance > 0) {
            vault.locked_withdrawBond(bondBalance);
        }

        // Now we have: workingCapital + bondBalance in base asset

        // Step 3: Deposit minimum payment back to working capital
        vault.locked_depositToWrapper(
            baseWrapper,
            WORKING_CAPITAL,
            minPayment
        );

        // Vault will take minPayment from our working capital
        // We keep (workingCapital + bondBalance - minPayment) as profit
    }
}

Example

Manager Position:
- Working Capital: $50K
- Bond: $20K
- Total Collateral: $70K
- Debt: $60K

Liquidation:
- Min Payment (underwater): $60K
- Liquidator receives: $70K total
- Liquidator pays: $60K
- Liquidator profit: $10K (seized collateral - debt)

No capital required!

Advantages

• Zero capital required

• No external funding needed

• Simple implementation

• Gas efficient

Limitations

• Only works if collateral > min payment

• Collateral already in base asset (or must swap)

• Lower profit than leveraged strategies

---

Strategy 2: Leveraged Liquidation

Borrow from the vault itself to increase your liquidation capacity and profit.

Concept

During liquidation callback, become a manager by borrowing from the vault. Use that borrowed capital plus seized collateral to maximize profit.

1. Receive manager's positions
2. Borrow additional capital from vault (locked_borrow)
3. Use seized collateral + borrowed capital for liquidation
4. Repay borrowed capital (locked_repay)
5. Keep profit

Implementation

contract LeveragedLiquidator is IFluxUnlockCallback {
    IFluxVault public immutable vault;
    IAsset public immutable baseWrapper;
    IERC20 public immutable baseAsset;
    address public immutable owner;
    ISwapRouter public immutable swapRouter;

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

        (uint256 minPayment, uint256 trueDebt, ) =
            abi.decode(data, (uint256, uint256, bytes));

        // Step 1: Withdraw all seized positions
        uint256 seizedWorkingCapital = vault.getWorkingCapital(owner);
        if (seizedWorkingCapital > 0) {
            vault.locked_withdrawFromWrapper(
                baseWrapper,
                WORKING_CAPITAL,
                seizedWorkingCapital
            );
        }

        uint256 seizedBond = vault.getBondBalance(owner);
        if (seizedBond > 0) {
            vault.locked_withdrawBond(seizedBond);
        }

        // Step 2: Withdraw collateral from other wrappers
        address[] memory wrappers = vault.registeredWrappers(owner);
        uint256 totalUnwound = 0;

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

            // Get position value
            uint256 value = IAsset(wrappers[i]).getValue(
                address(vault),
                owner,
                WORKING_CAPITAL  // or enumerate all positions
            );

            if (value > 0) {
                // Withdraw from wrapper
                vault.locked_withdrawFromWrapper(
                    IAsset(wrappers[i]),
                    WORKING_CAPITAL,
                    type(uint256).max
                );

                // Get underlying token
                address token = IAsset(wrappers[i]).underlyingAsset();
                uint256 balance = IERC20(token).balanceOf(address(this));

                // Swap to base asset for better price
                uint256 baseReceived = _swapToBase(token, balance);
                totalUnwound += baseReceived;
            }
        }

        // Current total: seizedWorkingCapital + seizedBond + totalUnwound
        uint256 totalSeized = seizedWorkingCapital + seizedBond + totalUnwound;

        // Step 3: Calculate if we need more capital
        if (totalSeized < minPayment) {
            // Borrow the deficit from vault!
            uint256 needToBorrow = minPayment - totalSeized;

            // Need to post bond first (10% of borrow)
            uint256 bondRequired = needToBorrow / 10;

            vault.locked_depositBond(bondRequired);
            vault.locked_borrow(needToBorrow);

            // Now we have enough to pay minPayment
            vault.locked_depositToWrapper(
                baseWrapper,
                WORKING_CAPITAL,
                minPayment
            );

            // Repay the borrow
            vault.locked_repay(needToBorrow);
            vault.locked_withdrawBond(bondRequired);

        } else {
            // We have enough, just deposit minPayment
            vault.locked_depositToWrapper(
                baseWrapper,
                WORKING_CAPITAL,
                minPayment
            );
        }

        // Profit = totalSeized - minPayment (minus any swap slippage)
    }

    function _swapToBase(address token, uint256 amount) internal returns (uint256) {
        IERC20(token).approve(address(swapRouter), amount);

        return swapRouter.exactInputSingle(
            ISwapRouter.ExactInputSingleParams({
                tokenIn: token,
                tokenOut: address(baseAsset),
                fee: 3000,
                recipient: address(this),
                deadline: block.timestamp,
                amountIn: amount,
                amountOutMinimum: 0, // Use proper slippage in production!
                sqrtPriceLimitX96: 0
            })
        );
    }
}

Example

Manager Position:
- Working Capital: $30K WETH
- Bond: $10K USDC
- Wrapper: $25K WBTC
- Total Collateral: $65K
- Debt: $60K

Liquidation:
1. Seize positions ($65K total)
2. Swap WETH → USDC: $30K
3. Swap WBTC → USDC: $25K
4. Have $65K USDC total
5. Need to pay: $60K
6. Profit: $5K USDC

With Leverage (if collateral < debt):
1. Seize positions: $40K
2. Borrow from vault: $20K (need $4K bond)
3. Total available: $60K
4. Pay debt: $60K
5. Repay borrow: $20K
6. Withdraw bond: $4K
7. Net profit: $40K - $20K - $4K = $16K

Profitable even when collateral < debt!

Advantages

• Can liquidate positions even with insufficient collateral

• Maximize profit by using vault capital

• Handle complex multi-asset positions

• Optimize swaps for best prices

Limitations

• More complex implementation

• Higher gas costs

• Requires bond posting

• Must repay borrowed capital

---

Strategy 3: Recursive/Nested Liquidation

Open a position against the vault to liquidate another manager.

This is the most advanced strategy: You become a manager yourself, borrow capital, use it to liquidate another manager, and close your position in the same transaction.

Concept

1. Register as manager with vault
2. During YOUR unlock callback:
   - Borrow capital from vault
   - Call vault.liquidate(otherManager)
   - During liquidation callback:
     - Receive other manager's positions
     - Liquidate them to base asset
     - Deposit payment
   - Repay your borrow
   - Close your position
3. Keep profit

Implementation

contract RecursiveLiquidator is IFluxUnlockCallback {
    IFluxVault public immutable vault;
    IERC20 public immutable baseAsset;
    IAsset public immutable baseWrapper;
    address public immutable owner;
    ISwapRouter public immutable swapRouter;

    // Track nested callback depth
    uint256 private callbackDepth;
    address private targetManager;
    uint256 private borrowedAmount;

    /**
     * @notice Execute recursive liquidation
     * @param manager The manager to liquidate
     */
    function executeLiquidation(address manager) external {
        require(msg.sender == owner, "Only owner");

        // Store target for callback
        targetManager = manager;

        // Calculate how much to borrow
        uint256 trueDebt = vault.getManagerTrueDebt(manager);
        borrowedAmount = trueDebt * 110 / 100; // Borrow 110% of debt

        // Trigger our own unlock to get vault capital
        vault.unlock("");
    }

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

        callbackDepth++;

        if (callbackDepth == 1) {
            // FIRST CALLBACK: We're borrowing to liquidate
            _firstCallback_BorrowAndLiquidate();
        } else {
            // SECOND CALLBACK: We're inside liquidation of target manager
            _secondCallback_LiquidateTarget(data);
        }

        callbackDepth--;
    }

    function _firstCallback_BorrowAndLiquidate() internal {
        // Step 1: Post bond
        uint256 bondAmount = borrowedAmount / 5; // 20% bond
        vault.locked_depositBond(bondAmount);

        // Step 2: Borrow capital
        vault.locked_borrow(borrowedAmount);

        // Step 3: Withdraw borrowed capital
        vault.locked_withdrawFromWrapper(
            baseWrapper,
            WORKING_CAPITAL,
            borrowedAmount
        );

        // Step 4: Approve vault for liquidation payment
        baseAsset.approve(address(vault), type(uint256).max);

        // Step 5: Liquidate target manager
        // This will trigger ANOTHER callback (depth 2)
        vault.liquidate(targetManager, new IAsset[](0), "");

        // Step 6: After liquidation completes, we have profit
        // Deposit borrowed amount back to working capital
        vault.locked_depositToWrapper(
            baseWrapper,
            WORKING_CAPITAL,
            borrowedAmount
        );

        // Step 7: Repay borrow
        vault.locked_repay(borrowedAmount);

        // Step 8: Withdraw bond
        vault.locked_withdrawBond(bondAmount);

        // Step 9: Withdraw profit
        uint256 profit = vault.getWorkingCapital(owner);
        if (profit > 0) {
            vault.locked_withdrawFromWrapper(
                baseWrapper,
                WORKING_CAPITAL,
                profit
            );
        }
    }

    function _secondCallback_LiquidateTarget(bytes calldata data) internal {
        // We're inside liquidation callback for target manager
        (uint256 minPayment, uint256 trueDebt, ) =
            abi.decode(data, (uint256, uint256, bytes));

        // Step 1: Withdraw all seized collateral
        uint256 seizedWorkingCapital = vault.getWorkingCapital(owner);
        if (seizedWorkingCapital > 0) {
            vault.locked_withdrawFromWrapper(
                baseWrapper,
                WORKING_CAPITAL,
                seizedWorkingCapital
            );
        }

        uint256 seizedBond = vault.getBondBalance(owner);
        if (seizedBond > 0) {
            vault.locked_withdrawBond(seizedBond);
        }

        // Step 2: Unwind any wrapper positions
        uint256 totalUnwound = _unwindWrappers();

        // Step 3: Calculate payment
        uint256 totalSeized = seizedWorkingCapital + seizedBond + totalUnwound;

        // We borrowed enough capital, so use it to pay
        // Deposit minPayment to our working capital
        vault.locked_depositToWrapper(
            baseWrapper,
            WORKING_CAPITAL,
            minPayment
        );

        // Anything extra from seized collateral is our profit
        // It stays in this contract and we withdraw it in first callback
    }

    function _unwindWrappers() internal returns (uint256 totalUnwound) {
        address[] memory wrappers = vault.registeredWrappers(owner);

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

            bytes32[] memory positionIds = _getPositionIds(owner, wrappers[i]);

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

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

                    address token = IAsset(wrappers[i]).underlyingAsset();
                    uint256 balance = IERC20(token).balanceOf(address(this));

                    uint256 baseReceived = _swapToBase(token, balance);
                    totalUnwound += baseReceived;
                }
            }
        }
    }

    function _swapToBase(address token, uint256 amount) internal returns (uint256) {
        // Same as previous examples
        IERC20(token).approve(address(swapRouter), amount);
        return swapRouter.exactInputSingle(
            ISwapRouter.ExactInputSingleParams({
                tokenIn: token,
                tokenOut: address(baseAsset),
                fee: 3000,
                recipient: address(this),
                deadline: block.timestamp,
                amountIn: amount,
                amountOutMinimum: 0,
                sqrtPriceLimitX96: 0
            })
        );
    }

    function _getPositionIds(address manager, address wrapper) internal view returns (bytes32[] memory) {
        // Implementation depends on wrapper tracking
        // Could use subgraph, events, or on-chain enumeration
        bytes32[] memory ids = new bytes32[](1);
        ids[0] = WORKING_CAPITAL;
        return ids;
    }
}

Execution Flow

Call: recursiveLiquidator.executeLiquidation(bobAddress)
  │
  ├─> vault.unlock("")
  │    │
  │    └─> fluxUnlockCallback (depth=1)
  │         │
  │         ├─> locked_depositBond(bondAmount)
  │         ├─> locked_borrow(borrowedAmount)
  │         ├─> locked_withdrawFromWrapper(baseWrapper, borrowedAmount)
  │         │
  │         ├─> vault.liquidate(bob, [], "")
  │         │    │
  │         │    └─> fluxUnlockCallback (depth=2)
  │         │         │
  │         │         ├─> Seize bob's positions
  │         │         ├─> Unwind bob's wrappers
  │         │         ├─> locked_depositToWrapper(minPayment)
  │         │         └─> Return (vault verifies payment)
  │         │
  │         ├─> locked_depositToWrapper(baseWrapper, borrowedAmount)
  │         ├─> locked_repay(borrowedAmount)
  │         ├─> locked_withdrawBond(bondAmount)
  │         └─> locked_withdrawFromWrapper(profit)
  │
  └─> Complete (liquidator has profit in baseAsset)

Example

Target Manager (Bob):
- Collateral: $100K (various assets)
- Debt: $95K
- Health: 105% (liquidatable, threshold = 110%)

Liquidator Strategy:
1. Borrow $105K from vault (need $21K bond)
2. Liquidate Bob's position
   - Min payment: $95K
   - Seize: $100K collateral
3. Pay $95K debt from borrowed capital
4. Keep $5K seized collateral as profit
5. Repay $105K borrow
6. Withdraw $21K bond
7. Net profit: $5K seized - $10K (borrow interest/costs) = Still profitable!

Can liquidate using vault's own capital
No external funding needed
Atomic execution (can't fail partway)

Advantages

• True capital-free: Use vault's own capital

• Can liquidate very large positions

• Atomic execution

• No need for external funding

• Scales with vault size

Limitations

• Very complex implementation

• High gas costs (nested callbacks)

• Requires tracking callback depth

• Must manage bond requirements

• Vault must have idle liquidity

---

Strategy 4: Flash Loan Liquidation

Use external flash loans to liquidate, then repay the flash loan from seized collateral.

Concept

1. Take flash loan (Aave, Uniswap, etc.)
2. Liquidate manager position
3. Unwind seized collateral
4. Repay flash loan + fee
5. Keep profit

Implementation

contract FlashLoanLiquidator is IFluxUnlockCallback, IFlashLoanReceiver {
    IFluxVault public immutable vault;
    ILendingPool public immutable aave;
    ISwapRouter public immutable swapRouter;
    IERC20 public immutable baseAsset;
    IAsset public immutable baseWrapper;
    address public immutable owner;

    struct LiquidationParams {
        address manager;
        uint256 loanAmount;
        IAsset[] additionalWrappers;
    }

    function liquidateWithFlashLoan(
        address manager,
        uint256 loanAmount,
        IAsset[] memory additionalWrappers
    ) external {
        require(msg.sender == owner, "Only owner");

        LiquidationParams memory params = LiquidationParams({
            manager: manager,
            loanAmount: loanAmount,
            additionalWrappers: additionalWrappers
        });

        // Request flash loan
        address[] memory assets = new address[](1);
        assets[0] = address(baseAsset);

        uint256[] memory amounts = new uint256[](1);
        amounts[0] = loanAmount;

        uint256[] memory modes = new uint256[](1);
        modes[0] = 0; // No debt mode

        aave.flashLoan(
            address(this),
            assets,
            amounts,
            modes,
            address(this),
            abi.encode(params),
            0 // referral code
        );
    }

    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        require(msg.sender == address(aave), "Only Aave");
        require(initiator == address(this), "Only self");

        LiquidationParams memory liquidationParams =
            abi.decode(params, (LiquidationParams));

        // We have flash loaned capital
        uint256 loanAmount = amounts[0];
        uint256 premium = premiums[0];

        // Approve vault for liquidation payment
        baseAsset.approve(address(vault), type(uint256).max);

        // Liquidate manager
        vault.liquidate(
            liquidationParams.manager,
            liquidationParams.additionalWrappers,
            abi.encode(loanAmount, premium)
        );

        // After liquidation, we should have enough to repay loan + premium
        uint256 owed = loanAmount + premium;
        baseAsset.approve(address(aave), owed);

        return true; // Aave will pull owed amount
    }

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

        // Decode liquidation params + flash loan info
        (uint256 minPayment, uint256 trueDebt, bytes memory additionalData) =
            abi.decode(data, (uint256, uint256, bytes));

        (uint256 loanAmount, uint256 premium) =
            abi.decode(additionalData, (uint256, uint256));

        // Step 1: Withdraw seized collateral
        uint256 seizedWorkingCapital = vault.getWorkingCapital(owner);
        if (seizedWorkingCapital > 0) {
            vault.locked_withdrawFromWrapper(
                baseWrapper,
                WORKING_CAPITAL,
                seizedWorkingCapital
            );
        }

        uint256 seizedBond = vault.getBondBalance(owner);
        if (seizedBond > 0) {
            vault.locked_withdrawBond(seizedBond);
        }

        // Step 2: Unwind wrapper positions
        uint256 unwoundValue = _unwindAllWrappers();

        uint256 totalSeized = seizedWorkingCapital + seizedBond + unwoundValue;

        // Step 3: Pay minPayment from flash loan capital
        vault.locked_depositToWrapper(
            baseWrapper,
            WORKING_CAPITAL,
            minPayment
        );

        // After callback, vault takes minPayment
        // We have: loanAmount - minPayment + totalSeized
        // Must repay: loanAmount + premium
        // Profit = totalSeized - premium
    }

    function _unwindAllWrappers() internal returns (uint256 total) {
        // Similar to previous examples
        // Swap all seized wrapper positions to base asset
    }
}

Example

Manager Position:
- Collateral: $110K
- Debt: $100K
- Health: 110% (liquidatable)

Flash Loan Strategy:
1. Flash loan: $100K USDC (0.09% fee = $90)
2. Liquidate manager
   - Pay: $100K
   - Seize: $110K collateral
3. Unwind collateral: $110K → $109K (1% slippage)
4. Repay flash loan: $100K + $90 = $100,090
5. Profit: $109K - $100,090 = $8,910

No capital required
Can liquidate very large positions
Pay only 0.09% flash loan fee

Advantages

• No capital required

• Can liquidate unlimited size positions

• Pay minimal flash loan fees

• No vault borrowing (don't become manager)

Limitations

• Requires flash loan provider integration

• Flash loan fees eat into profit

• Must repay same transaction

• Complex error handling

---

Strategy 5: Cross-Protocol Arbitrage

Liquidate positions and sell on external DEXs for better prices.

Concept

Instead of just unwinding positions to base asset, route through multiple DEXs to maximize profit:

1. Seize manager's WETH position
2. Check prices:
   - Uniswap: 1 WETH = 2500 USDC
   - SushiSwap: 1 WETH = 2505 USDC
   - Curve: 1 WETH = 2502 USDC
3. Route through SushiSwap for best price
4. Extra $5 per WETH profit!

Implementation

contract ArbitrageLiquidator is IFluxUnlockCallback {
    IFluxVault public immutable vault;
    IAsset public immutable baseWrapper;
    address public immutable owner;

    // Multiple DEX routers
    ISwapRouter public immutable uniswapRouter;
    ISwapRouter public immutable sushiswapRouter;
    ICurvePool public immutable curvePool;

    struct SwapRoute {
        address router;
        uint256 expectedOutput;
    }

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

        (uint256 minPayment, uint256 trueDebt, ) =
            abi.decode(data, (uint256, uint256, bytes));

        // Withdraw seized collateral
        _withdrawAllPositions();

        // For each asset, find best swap route
        address[] memory wrappers = vault.registeredWrappers(owner);
        uint256 totalProceeds = 0;

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

            address token = IAsset(wrappers[i]).underlyingAsset();
            uint256 balance = IERC20(token).balanceOf(address(this));

            if (balance > 0) {
                // Find best route
                SwapRoute memory bestRoute = _findBestRoute(token, balance);

                // Execute swap on best DEX
                uint256 received = _executeSwap(bestRoute, token, balance);
                totalProceeds += received;
            }
        }

        // Add any direct base asset
        totalProceeds += vault.getWorkingCapital(owner);
        totalProceeds += vault.getBondBalance(owner);

        // Deposit minPayment
        vault.locked_depositToWrapper(
            baseWrapper,
            WORKING_CAPITAL,
            minPayment
        );

        // Profit = totalProceeds - minPayment
    }

    function _findBestRoute(address token, uint256 amount)
        internal
        view
        returns (SwapRoute memory)
    {
        uint256 uniswapQuote = _getUniswapQuote(token, amount);
        uint256 sushiQuote = _getSushiswapQuote(token, amount);
        uint256 curveQuote = _getCurveQuote(token, amount);

        if (uniswapQuote >= sushiQuote && uniswapQuote >= curveQuote) {
            return SwapRoute(address(uniswapRouter), uniswapQuote);
        } else if (sushiQuote >= curveQuote) {
            return SwapRoute(address(sushiswapRouter), sushiQuote);
        } else {
            return SwapRoute(address(curvePool), curveQuote);
        }
    }

    function _executeSwap(SwapRoute memory route, address tokenIn, uint256 amount)
        internal
        returns (uint256)
    {
        IERC20(tokenIn).approve(route.router, amount);

        if (route.router == address(curvePool)) {
            return _swapOnCurve(tokenIn, amount);
        } else {
            return _swapOnUniswapV3(route.router, tokenIn, amount);
        }
    }

    // Price checking functions
    function _getUniswapQuote(address token, uint256 amount)
        internal view returns (uint256)
    {
        // Use Uniswap quoter
    }

    function _getSushiswapQuote(address token, uint256 amount)
        internal view returns (uint256)
    {
        // Use Sushiswap quoter
    }

    function _getCurveQuote(address token, uint256 amount)
        internal view returns (uint256)
    {
        // Use Curve get_dy
    }
}

Advantages

• Maximize profit through best execution

• Reduce slippage by routing optimally

• Can capture arbitrage opportunities

• Better for large liquidations

Limitations

• More gas intensive (multiple quote checks)

• Requires maintaining multiple DEX integrations

• Quotes may be stale by execution time

• Increased complexity

---

Comparison of Strategies

Strategy	Capital Required	Complexity	Gas Cost	Max Profit	Best For
Capital-Free	None	Low	Low	Medium	Simple positions, base asset collateral
Leveraged	None (vault capital)	Medium	Medium	High	Complex multi-asset positions
Recursive	None (vault capital)	Very High	High	Very High	Large positions, low vault utilization
Flash Loan	None (flash loan)	High	Medium	High	Very large positions
Arbitrage	Varies	High	High	Highest	Multi-asset positions, volatile markets

---

Best Practices

For All Strategies

Do:

• Calculate gas costs before executing

• Check vault has sufficient idle liquidity (for borrowing strategies)

• Verify position is still liquidatable before executing

• Use proper slippage protection on DEX swaps

• Test on testnet/fork first

• Handle all error cases gracefully

Don't:

• Assume seized collateral is in base asset

• Ignore flash loan fees in profit calculation

• Use unlimited approvals carelessly

• Forget to repay borrowed capital

• Skip callback depth tracking for recursive strategies

Gas Optimization

// Bad: Multiple separate withdrawals
for (uint i = 0; i < wrappers.length; i++) {
    vault.locked_withdrawFromWrapper(wrappers[i], posId, amount);
}

// Good: Batch withdrawals where possible
bytes[] memory calls = new bytes[](wrappers.length);
for (uint i = 0; i < wrappers.length; i++) {
    calls[i] = abi.encodeCall(
        vault.locked_withdrawFromWrapper,
        (wrappers[i], posId, amount)
    );
}
// Execute batch

Profit Calculation

Always account for all costs:

function calculateExpectedProfit(
    address manager,
    uint256 flashLoanFee
) external view returns (int256) {
    // Get liquidation params
    (bool canLiquidate, uint256 minPayment, ) =
        strategy.evaluateLiquidation(address(vault), manager);

    if (!canLiquidate) return 0;

    // Estimate seized collateral value
    uint256 collateralValue = lens.getManagerPositionValue(
        address(vault),
        manager
    );

    // Estimate swap slippage (1%)
    uint256 expectedProceeds = collateralValue * 99 / 100;

    // Calculate profit
    int256 profit = int256(expectedProceeds)
                  - int256(minPayment)
                  - int256(flashLoanFee)
                  - int256(estimatedGasCost);

    return profit;
}

Error Handling

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

    try this._executeLiquidation(data) {
        // Success
    } catch Error(string memory reason) {
        // Handle revert with reason
        emit LiquidationFailed(reason);

        // Ensure we still meet minimum payment
        _depositMinimumPayment(data);
    } catch (bytes memory) {
        // Handle revert without reason
        emit LiquidationFailed("Unknown error");

        // Emergency: deposit any available capital
        _depositAvailableCapital();
    }
}

---

Security Considerations

Reentrancy Protection

Flux vault has nonReentrant on liquidate(), but be careful with external calls:

// Dangerous: External call before state update
function fluxUnlockCallback(bytes calldata data) external {
    externalProtocol.doSomething(); // Could reenter!
    vault.locked_depositToWrapper(...);
}

// Safe: Update state first
function fluxUnlockCallback(bytes calldata data) external {
    vault.locked_depositToWrapper(...); // Update vault state
    externalProtocol.doSomething(); // Then external call
}

Flash Loan Attacks

Verify liquidations are genuine, not manipulated:

// Check position was liquidatable BEFORE flash loan
function liquidateWithFlashLoan(address manager) external {
    // Pre-check
    (bool canLiquidate, , ) = strategy.evaluateLiquidation(vault, manager);
    require(canLiquidate, "Not liquidatable");

    // Then take flash loan
    // ...
}

Sandwich Attack Protection

Protect your swaps from MEV:

function _swapWithProtection(address token, uint256 amount) internal {
    // Get expected output from oracle
    uint256 fairPrice = oracle.getPrice(token);
    uint256 expectedOutput = amount * fairPrice / 1e18;

    // Allow 0.5% slippage
    uint256 minOutput = expectedOutput * 995 / 1000;

    // Execute swap with minimum
    swapRouter.exactInputSingle(
        ISwapRouter.ExactInputSingleParams({
            tokenIn: token,
            tokenOut: baseAsset,
            amountIn: amount,
            amountOutMinimum: minOutput, // Protected!
            // ...
        })
    );
}

---

Summary

Flux's liquidation callback system enables sophisticated capital-efficient strategies:

1. Capital-Free: Use seized collateral to pay for liquidation

2. Leveraged: Borrow from vault to amplify liquidation capacity

3. Recursive: Become a manager to liquidate another manager

4. Flash Loans: Use external flash loans for unlimited capital

5. Arbitrage: Route through multiple DEXs for maximum profit

Key Insight: Liquidators are temporary managers with full access to locked_* operations. This enables truly capital-free liquidations at any scale.

Choose your strategy based on:

• Position size

• Collateral composition

• Available capital

• Gas budget

• Vault liquidity

• Technical expertise