Position Management

Learn how to effectively manage your positions as a manager, including opening, monitoring, rebalancing, and closing positions in Flux Protocol.

Overview

As a manager in Flux, you borrow capital from vaults to execute trading strategies. Effective position management is critical to:

• Maintain healthy collateralization ratios

• Avoid liquidation

• Maximize returns

• Manage risk

---

Opening a Position

1. Choose a Vault

Select a vault that matches your strategy:

// Evaluate vault parameters
IFluxVault vault = IFluxVault(vaultAddress);
IStrategy strategy = vault.STRATEGY();

// Check interest rate
uint256 interestRate = strategy.interestRate();

// Check allowed assets
IAsset[] memory allowedAssets = strategy.getAllowedAssets();

// Check bond requirements
uint256 minBondRatio = strategy.minBondRatio();

2. Calculate Required Bond

// How much do you want to borrow?
uint256 borrowAmount = 100_000e6;  // 100k USDC

// Calculate required bond
uint256 minBondRatio = strategy.minBondRatio();  // e.g., 0.2e18 = 20%
uint256 requiredBond = borrowAmount * minBondRatio / 1e18;

// Example: 100k borrow * 20% = 20k bond required

3. Execute Borrow

// Approve bond token
IERC20 baseAsset = IERC20(vault.asset());
baseAsset.approve(address(vault), requiredBond);

// Borrow from vault
vault.borrow(
    borrowAmount,     // Amount to borrow
    requiredBond,     // Bond to post
    msg.sender        // Position owner
);

// You now have borrowAmount + requiredBond to deploy

4. Deploy Capital

Use borrowed capital to execute your strategy:

// Example: Swap to different assets
uint256 totalCapital = borrowAmount + requiredBond;

// Swap some to WETH
swapUSDCToWETH(totalCapital * 40 / 100);

// Provide liquidity
provideLiquidityToUniswap(totalCapital * 60 / 100);

---

Position Monitoring

Track Your Position

struct PositionInfo {
    uint256 borrowed;        // Amount borrowed from vault
    uint256 bond;            // Your bond/collateral
    uint256 debt;            // Current debt (principal + interest)
    uint256 positionValue;   // Current value of all assets
    uint256 healthRatio;     // Position health
    bool isLiquidatable;     // Can be liquidated
}

function getPositionInfo(address vault, address manager)
    public
    view
    returns (PositionInfo memory info)
{
    IFluxVault v = IFluxVault(vault);

    // Get position data
    (uint256 borrowed, uint256 bond) = v.getPosition(manager);

    // Calculate current debt
    uint256 debt = v.getDebt(manager);

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

    // Calculate health ratio
    uint256 healthRatio = positionValue * 1e18 / debt;

    // Check if liquidatable
    (, bool isLiquidatable) = v.evaluateLiquidation(manager);

    return PositionInfo(
        borrowed,
        bond,
        debt,
        positionValue,
        healthRatio,
        isLiquidatable
    );
}

Key Metrics

1. Health Ratio

   Health Ratio = Total Position Value / True Debt

   • 1.5: Very healthy

   • 1.2 - 1.5: Healthy

   • 1.1 - 1.2: Warning zone

   • < 1.1: Liquidation risk

2. Debt Growth

   True Debt = Principal + Accrued Interest

   • Monitor how fast debt grows

   • Interest accrues continuously

   • Pay down debt to reduce growth

3. Position Value

   Position Value = Sum of all asset values

   • Fluctuates with market prices

   • Includes unrealized P&L

   • Oracle-based valuation

---

Rebalancing Strategies

When to Rebalance

1. Health ratio approaching threshold

2. Market conditions change

3. Better opportunities available

4. Debt growing too fast

Rebalancing Actions

1. Add More Collateral

Increase position value without borrowing more:

function addCollateral(
    address vault,
    uint256 additionalAssets
) external {
    // Deposit more bond
    IERC20(baseAsset).approve(vault, additionalAssets);

    IFluxVault(vault).increaseBond(additionalAssets);

    // Health ratio improves
}

2. Repay Debt

Reduce debt to improve health ratio:

function partialRepay(
    address vault,
    uint256 repayAmount
) external {
    // Sell some assets for base asset
    uint256 baseAssets = sellAssetForBase(repayAmount);

    // Repay debt
    IERC20(baseAsset).approve(vault, baseAssets);
    IFluxVault(vault).repay(baseAssets);

    // Debt decreases, health ratio improves
}

3. Rotate Assets

Swap from declining to appreciating assets:

function rotateAssets(
    address fromAsset,
    address toAsset,
    uint256 amount
) external {
    // Sell declining asset
    withdrawAsset(fromAsset, amount);
    uint256 baseAssets = sellForBase(fromAsset, amount);

    // Buy appreciating asset
    uint256 newAmount = buyFromBase(toAsset, baseAssets);
    depositAsset(toAsset, newAmount);

    // Position value maintained or improved
}

4. Reduce Exposure

Take profits and reduce position size:

function reduceExposure(
    address vault,
    uint256 percentage  // 0-100
) external {
    PositionInfo memory info = getPositionInfo(vault, msg.sender);

    // Sell portion of assets
    uint256 sellAmount = info.positionValue * percentage / 100;
    uint256 baseAssets = liquidateAssets(sellAmount);

    // Repay debt
    uint256 repayAmount = min(baseAssets, info.debt);
    IERC20(baseAsset).approve(vault, repayAmount);
    IFluxVault(vault).repay(repayAmount);

    // Smaller position, better health ratio
}

---

Automated Position Management

Health Monitoring Bot

function monitorPosition(address vault) external {
    PositionInfo memory info = getPositionInfo(vault, msg.sender);

    if (info.healthRatio < 1.3e18) {
        // Critical: Take immediate action
        emergencyRebalance(vault);
    } else if (info.healthRatio < 1.5e18) {
        // Warning: Prepare to rebalance
        prepareRebalance(vault);
    }

    // Log health
    emit HealthUpdate(info.healthRatio, block.timestamp);
}

function emergencyRebalance(address vault) internal {
    // Option 1: Add collateral
    if (hasAvailableCollateral()) {
        addCollateral(vault, calculateNeededCollateral(vault));
    }
    // Option 2: Reduce position
    else {
        reduceExposure(vault, 30);  // Reduce by 30%
    }
}

Auto-Compound Profits

function autoCompound(address vault) external {
    PositionInfo memory info = getPositionInfo(vault, msg.sender);

    // Calculate unrealized profit
    uint256 totalValue = info.positionValue;
    uint256 invested = info.borrowed + info.bond;
    uint256 profit = totalValue > invested ? totalValue - invested : 0;

    if (profit > threshold) {
        // Sell portion of profit
        uint256 realizedProfit = realizeProfit(vault, profit / 2);

        // Repay debt to reduce interest
        IERC20(baseAsset).approve(vault, realizedProfit);
        IFluxVault(vault).repay(realizedProfit);
    }
}

---

Closing Positions

Full Position Close

function closePosition(address vault) external {
    IFluxVault v = IFluxVault(vault);

    // 1. Get current position
    PositionInfo memory info = getPositionInfo(vault, msg.sender);

    // 2. Liquidate all assets to base asset
    uint256 totalBase = liquidateAllAssets(vault);

    // 3. Repay debt
    uint256 repayAmount = min(totalBase, info.debt);
    IERC20(baseAsset).approve(vault, repayAmount);
    v.repay(repayAmount);

    // 4. Withdraw bond (if possible)
    if (info.debt == 0) {
        v.withdrawBond(info.bond);
    }

    // 5. Calculate final P&L
    uint256 finalBalance = totalBase - repayAmount + info.bond;
    int256 pnl = int256(finalBalance) - int256(info.bond);

    emit PositionClosed(pnl);
}

Partial Close

function partialClose(
    address vault,
    uint256 percentage  // 0-100
) external {
    // Close portion of position
    uint256 assetsToSell = getPositionValue(vault) * percentage / 100;
    uint256 baseAssets = liquidateAssets(assetsToSell);

    // Repay proportional debt
    uint256 debt = IFluxVault(vault).getDebt(msg.sender);
    uint256 repayAmount = debt * percentage / 100;

    IERC20(baseAsset).approve(vault, repayAmount);
    IFluxVault(vault).repay(repayAmount);
}

---

Position Strategies

Strategy 1: Delta Neutral

Maintain market-neutral exposure:

// Long spot, short perp
function deltaNeutralPosition(address vault) external {
    // Borrow 100k
    uint256 borrowed = 100_000e6;

    // Buy 50 ETH spot
    buyETH(50 ether);

    // Short 50 ETH perp
    openShort(50 ether);

    // Earn funding rate, neutral to ETH price
}

Strategy 2: Yield Farming

Leverage LP positions:

function leveragedFarming(address vault) external {
    // Borrow 100k USDC
    uint256 borrowed = 100_000e6;

    // Provide liquidity (borrowed + bond)
    uint256 totalCapital = borrowed + bond;
    provideLiquidity(totalCapital);

    // Earn trading fees + farm rewards
    // Amplified by leverage
}

Strategy 3: Arbitrage

Execute arbitrage opportunities:

function arbitrage(address vault) external {
    // Borrow 100k
    uint256 borrowed = 100_000e6;

    // Buy on DEX A
    uint256 tokenAmount = buyOnDEXA(borrowed);

    // Sell on DEX B
    uint256 received = sellOnDEXB(tokenAmount);

    // Profit = received - borrowed (minus fees)
    uint256 profit = received - borrowed;

    // Repay and keep profit
    repayAndClose(vault);
}

---

Risk Management

Position Sizing

// Never max out your position
uint256 maxBorrow = vault.maxBorrow(msg.sender);
uint256 safeBorrow = maxBorrow * 80 / 100;  // Only use 80%

// Keep buffer for market volatility

Stop-Loss

function checkStopLoss(address vault) external {
    PositionInfo memory info = getPositionInfo(vault, msg.sender);

    // Calculate P&L
    uint256 invested = info.borrowed + info.bond;
    int256 pnl = int256(info.positionValue) - int256(invested);
    int256 pnlPercent = pnl * 100 / int256(invested);

    // Stop-loss at -10%
    if (pnlPercent < -10) {
        closePosition(vault);
    }
}

Diversification

// Don't put all capital in one position
uint256 totalCapital = getTotalCapital();

// Spread across multiple vaults/strategies
vault1.borrow(totalCapital * 30 / 100);
vault2.borrow(totalCapital * 30 / 100);
vault3.borrow(totalCapital * 40 / 100);

---

Related Documentation

• Health Monitoring - Detailed health tracking

• Manager Integration Guide - Full integration guide

• Risk Management - Avoiding liquidation

• Weiroll Guide - Complex operations