Creating a Vault

This guide walks you through deploying and configuring a Flux vault as a curator. Learn how to choose parameters, select strategies, and launch a vault that provides verifiable safety for LPs.

Overview

As a vault curator, you:

• Choose a strategy that defines economic parameters and risk management

• Select an access policy (permissionless or whitelist)

• Deploy the vault via FluxVaultFactory

• Manage the vault to optimize for LP returns

• Earn curator fees from manager interest (if strategy allows)

Your Responsibility: Curate a vault that provides verifiable safety and competitive yields for LPs.

---

Pre-Deployment Checklist

Before deploying, decide:

1. Base Asset

What asset will LPs deposit and managers borrow?

Options:

• USDC (most common - stable, liquid)

• USDT (alternative stablecoin)

• DAI (decentralized stablecoin)

• WETH (ETH exposure)

• WBTC (BTC exposure)

Considerations:

• Liquidity (can it be easily swapped?)

• Oracle support (reliable price feeds?)

• LP demand (do LPs want to deposit this?)

• Manager demand (do managers want to borrow this?)

2. Strategy Type

Immutable (parameters locked) or Mutable (parameters can change)?

Immutable Strategy:

• No governance risk for LPs

• Predictable long-term

• Cannot adapt to market changes

• Best for: Conservative vaults, maximize LP trust

Mutable Strategy:

• Flexible - adapt to markets

• Can update rates/assets

• 7-day timelock on changes

• LPs may exit if they disagree

• Best for: Active management, competitive rates

3. Risk Parameters

Choose strategy parameters based on target risk profile:

Conservative Vault:

minBondRatio: 25-30% (3-4x leverage)
liquidationBuffer: 15-20% (early liquidations)
annualRate: 5-8% APR
curatorFeeRate: 0-5%
liquidationProfitMargin: 1-2%

Moderate Vault:

minBondRatio: 20-25% (4-5x leverage)
liquidationBuffer: 10-15% (balanced)
annualRate: 8-12% APR
curatorFeeRate: 5-10%
liquidationProfitMargin: 2-5%

Aggressive Vault:

minBondRatio: 15-20% (5-6.67x leverage)
liquidationBuffer: 5-10% (tight liquidations)
annualRate: 12-15% APR
curatorFeeRate: 10-15%
liquidationProfitMargin: 5-10%

4. Allowed Assets

Which asset wrappers can managers use?

Conservative: Only well-established assets

• WETH, WBTC, USDC, USDT

• Major blue-chip tokens

Moderate: Mix of established and newer

• Above + DAI, stETH, cbETH

• Vetted DeFi tokens

Aggressive: Broader range

• Above + newer yield-bearing tokens

• Emerging protocols (with research)

Critical: Only include assets with:

• Reliable oracles

• Sufficient liquidity

• Audited wrappers

• Strong security track record

5. Access Policy

Who can deposit/borrow?

Permissionless:

• Anyone can deposit

• Anyone can borrow (if they meet requirements)

• Maximum composability

• Best for: Public vaults, maximum TVL

Whitelist:

• Only approved addresses can deposit

• Only approved managers can borrow

• More control, less risk

• Best for: Private vaults, known participants

---

Deployment Steps

Step 1: Deploy or Choose a Strategy

Option A: Deploy New Strategy (Recommended for Control)

import {IStrategyFactory, StrategyParams} from "flux-v1-contracts/interfaces/IStrategyFactory.sol";

contract VaultDeployment {
    function deployStrategy(
        IStrategyFactory factory,
        address[] memory allowedAssets
    ) public returns (address strategy) {
        // Define parameters
        StrategyParams memory params = StrategyParams({
            minBondRatio: 0.2e18,            // 20% bond (5x leverage)
            liquidationBuffer: 0.1e18,        // 10% buffer before liquidation
            annualRate: 0.1e18,               // 10% APR
            curatorFeeRate: 1000,             // 10% curator fee (1000 bps)
            liquidationProfitMargin: 0.01e18  // 1% liquidator profit
        });

        // Deploy immutable strategy (parameters locked forever)
        strategy = factory.deployImmutableStrategy(allowedAssets, params);

        // OR deploy mutable strategy (7-day timelock on changes)
        // strategy = factory.deployMutableStrategy(allowedAssets, params, msg.sender);
    }
}

Option B: Use Existing Strategy

// Use a pre-deployed strategy if it matches your needs
address strategy = 0x...;  // Existing strategy address

// Verify it has the parameters you want
IStrategy s = IStrategy(strategy);
require(s.minBondRatio() == 0.2e18, "Wrong bond ratio");
require(s.annualRate() == 0.1e18, "Wrong rate");

Step 2: Deploy Base Asset Wrapper

import {IAssetWrapperFactory} from "flux-v1-contracts/interfaces/IAssetWrapperFactory.sol";

function deployBaseAssetWrapper(
    IAssetWrapperFactory wrapperFactory,
    address baseAsset
) public returns (address wrapper) {
    // Check if wrapper already exists
    wrapper = wrapperFactory.getWrapper(baseAsset);

    if (wrapper == address(0)) {
        // Deploy new wrapper
        wrapper = wrapperFactory.deployERC20Wrapper(baseAsset);
    }

    // Ensure it's whitelisted
    require(
        fluxVaultFactory.whitelistedAssets(wrapper),
        "Wrapper not whitelisted"
    );
}

Step 3: Deploy Access Policy (If Needed)

import {WhitelistAccessPolicy} from "flux-v1-contracts/access/WhitelistAccessPolicy.sol";

function deployAccessPolicy() public returns (address policy) {
    // For permissionless vault, use address(0)
    // For whitelist vault, deploy policy

    WhitelistAccessPolicy wp = new WhitelistAccessPolicy(msg.sender);

    // Add initial whitelisted LPs
    wp.setWhitelistedLP(lpAddress1, true);
    wp.setWhitelistedLP(lpAddress2, true);

    // Add initial whitelisted managers
    wp.setWhitelistedManager(managerAddress1, true);

    return address(wp);
}

Step 4: Deploy Vault

import {IFluxVaultFactory} from "flux-v1-contracts/interfaces/IFluxVaultFactory.sol";

function deployVault(
    IFluxVaultFactory factory,
    address baseAsset,
    address baseAssetWrapper,
    address strategy,
    address accessPolicy
) public returns (address vault) {
    // Deploy vault
    vault = factory.createVault(
        IERC20(baseAsset),
        IAsset(baseAssetWrapper),
        IStrategy(strategy),
        IAccessPolicy(accessPolicy),
        "My Flux Vault",      // Vault name
        "MFV"                 // Share symbol
    );

    // Vault deployed! Address logged in event
}

Step 5: Verify Deployment

function verifyVault(IFluxVault vault) public view returns (bool valid) {
    // Check immutables are correct
    require(vault.STRATEGY() == expectedStrategy, "Wrong strategy");
    require(vault.FACTORY() == expectedFactory, "Wrong factory");
    require(vault.VAULT_CREATOR() == msg.sender, "Wrong creator");

    // Check vault is operational
    require(vault.totalAssets() >= 0, "Vault not initialized");

    return true;
}

---

Post-Deployment Setup

1. Seed Initial Liquidity

function seedVault(IFluxVault vault, uint256 amount) external {
    IERC20 baseAsset = IERC20(vault.asset());

    // Approve and deposit
    baseAsset.approve(address(vault), amount);
    vault.deposit(amount, msg.sender);

    // Recommended: Seed with at least 10K-100K to demonstrate commitment
}

2. Market Your Vault

Highlight:

• Verifiable safety (collateralized positions, transparent parameters)

• Strategy parameters (rates, allowed assets)

• Curator background/reputation

• Estimated APY for LPs

Channels:

• Flux app (if whitelisted)

• Twitter/social media

• DeFi yield aggregators

• Community forums

3. Monitor Vault Health

function getVaultMetrics(IFluxVault vault) public view returns (
    uint256 totalAssets,
    uint256 utilization,
    uint256 estimatedAPY,
    uint256 numManagers
) {
    totalAssets = vault.totalAssets();
    uint256 totalDebt = vault.totalPrincipalDebt();
    utilization = totalAssets > 0 ? (totalDebt * 1e18) / totalAssets : 0;

    // Estimate APY from interest rate and utilization
    IStrategy strategy = vault.STRATEGY();
    uint256 annualRate = strategy.annualRate();
    estimatedAPY = (annualRate * utilization) / 1e18;

    // Count managers (implement via event tracking)
    numManagers = countActiveManagers(vault);
}

---

Managing Your Vault

Collecting Curator Fees

function collectFees(IFluxVault vault) external {
    // Collect accumulated creator fees
    uint256 collected = vault.transferCreatorFees();

    // Fees sent to vault creator (you)
    console.log("Collected fees:", collected);
}

Monitoring Manager Activity

// Off-chain monitoring
async function monitorManagers(vaultAddress: string) {
  const vault = await getVaultContract(vaultAddress);

  // Track all managers via events
  const borrowEvents = await vault.queryFilter(vault.filters.Borrowed());

  for (const event of borrowEvents) {
    const manager = event.args.manager;

    // Check health
    const healthRatio = await getHealthRatio(vault, manager);

    if (healthRatio < 1.15e18) {
      alert(`Manager ${manager} health low: ${healthRatio}`);
    }
  }
}

Updating Mutable Strategy Parameters

If using MutableFixedRateStrategy:

function queueRateChange(
    IMutableStrategy strategy,
    uint256 newRate
) external {
    // Queue new annual rate
    strategy.queueAnnualRateChange(newRate);

    // Must wait 7 days before executing
}

function executeRateChange(IMutableStrategy strategy) external {
    // After 7 days, execute the change
    strategy.executeAnnualRateChange();

    // New rate now active
}

Important: LPs can exit during timelock if they disagree with changes.

---

Vault Templates

Template 1: Conservative USDC Vault

function deployConservativeUSDCVault() external returns (address) {
    // Strategy parameters
    address[] memory allowedAssets = new address[](3);
    allowedAssets[0] = WETH_WRAPPER;
    allowedAssets[1] = WBTC_WRAPPER;
    allowedAssets[2] = USDC_WRAPPER;

    StrategyParams memory params = StrategyParams({
        minBondRatio: 0.25e18,           // 25% bond (4x leverage)
        liquidationBuffer: 0.15e18,       // 15% buffer
        annualRate: 0.06e18,              // 6% APR
        curatorFeeRate: 500,              // 5% curator fee
        liquidationProfitMargin: 0.01e18  // 1% liquidator profit
    });

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

    return fluxVaultFactory.createVault(
        IERC20(USDC),
        IAsset(USDC_WRAPPER),
        IStrategy(strategy),
        IAccessPolicy(address(0)),  // Permissionless
        "Conservative USDC Vault",
        "cUSDCV"
    );
}

Template 2: Aggressive Stablecoin Vault

function deployAggressiveStablecoinVault() external returns (address) {
    // More assets allowed
    address[] memory allowedAssets = new address[](8);
    allowedAssets[0] = WETH_WRAPPER;
    allowedAssets[1] = WBTC_WRAPPER;
    allowedAssets[2] = STETH_WRAPPER;
    allowedAssets[3] = CBETH_WRAPPER;
    allowedAssets[4] = USDC_WRAPPER;
    allowedAssets[5] = DAI_WRAPPER;
    allowedAssets[6] = AAVE_USDC_WRAPPER;  // aUSDC
    allowedAssets[7] = CURVE_3POOL_WRAPPER;

    StrategyParams memory params = StrategyParams({
        minBondRatio: 0.15e18,           // 15% bond (6.67x leverage)
        liquidationBuffer: 0.05e18,       // 5% buffer (tight)
        annualRate: 0.12e18,              // 12% APR
        curatorFeeRate: 1500,             // 15% curator fee
        liquidationProfitMargin: 0.05e18  // 5% liquidator profit
    });

    // Mutable strategy for flexibility
    address strategy = strategyFactory.deployMutableStrategy(
        allowedAssets,
        params,
        msg.sender  // You can update parameters
    );

    return fluxVaultFactory.createVault(
        IERC20(USDC),
        IAsset(USDC_WRAPPER),
        IStrategy(strategy),
        IAccessPolicy(address(0)),
        "Aggressive Stablecoin Vault",
        "aUSDCV"
    );
}

Template 3: Institutional Whitelist Vault

function deployInstitutionalVault() external returns (address) {
    // Deploy whitelist policy
    WhitelistAccessPolicy policy = new WhitelistAccessPolicy(msg.sender);

    // Add institutional LPs and managers
    policy.setWhitelistedLP(INSTITUTION_1, true);
    policy.setWhitelistedLP(INSTITUTION_2, true);
    policy.setWhitelistedManager(FUND_MANAGER_1, true);
    policy.setWhitelistedManager(FUND_MANAGER_2, true);

    // Conservative parameters for institutions
    address[] memory allowedAssets = new address[](4);
    allowedAssets[0] = WETH_WRAPPER;
    allowedAssets[1] = WBTC_WRAPPER;
    allowedAssets[2] = STETH_WRAPPER;
    allowedAssets[3] = USDC_WRAPPER;

    StrategyParams memory params = StrategyParams({
        minBondRatio: 0.3e18,            // 30% bond (3.33x leverage)
        liquidationBuffer: 0.2e18,        // 20% buffer (very safe)
        annualRate: 0.08e18,              // 8% APR
        curatorFeeRate: 1000,             // 10% curator fee
        liquidationProfitMargin: 0.01e18  // 1% liquidator profit
    });

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

    return fluxVaultFactory.createVault(
        IERC20(USDC),
        IAsset(USDC_WRAPPER),
        IStrategy(strategy),
        IAccessPolicy(address(policy)),  // Whitelist
        "Institutional USDC Vault",
        "iUSDCV"
    );
}

---

Best Practices

1. Start Conservative

First vault: High bond ratio, low leverage, established assets only
After proving track record: Can launch more aggressive vaults

2. Transparent Communication

• Publish strategy parameters publicly

• Explain risk/return tradeoffs

• Announce parameter changes in advance (mutable strategies)

• Share vault performance metrics

3. Active Monitoring

// Monitor daily
const dailyChecks = {
  vaultUtilization: ">90%? Consider incentivizing more LPs",
  managerHealth: "Any near liquidation? Alert them",
  oraclePrices: "Any unusual movements? Investigate",
  totalAssets: "Growing or shrinking? Analyze why",
};

4. Risk Management

• Diversify allowed assets

• Vet wrappers thoroughly before adding

• Monitor oracle reliability

• Track liquidation success rate

5. Competitive Rates

// Benchmark against competitors
const competitiveAnalysis = {
  yourVault: { apy: 8.5, risk: "Low" },
  competitor1: { apy: 10.0, risk: "Medium" },
  competitor2: { apy: 6.5, risk: "Low" },
  // Adjust your rates to stay competitive
};

Common Mistakes to Avoid

Too Aggressive Initially

• Don't start with 10% bond ratio

• Don't allow untested assets

• Build reputation first

Poor Asset Selection

• Don't include assets without reliable oracles

• Don't include illiquid assets (can't liquidate)

• Vet wrapper contracts thoroughly

Ignoring Curator Responsibilities

• Don't deploy and forget

• Monitor vault health regularly

• Respond to LP questions/concerns

Unrealistic Yield Promises

• Don't promise specific APYs (they vary with utilization)

• Be transparent about risks

• Show historical performance honestly

Poor Communication

• Don't make parameter changes without warning (mutable)

• Don't hide liquidation events

• Be available to LPs and managers

---

Success Metrics

Track these metrics to gauge vault success:

interface VaultMetrics {
  // Growth
  totalAssets: bigint; // Target: Growing steadily
  numLPs: number; // Target: Growing
  numManagers: number; // Target: 3-10 active

  // Health
  utilization: number; // Target: 60-80%
  avgHealthRatio: number; // Target: >150%
  liquidationRate: number; // Target: <5% of positions

  // Performance
  lpAPY: number; // Target: Competitive
  curatorFees: bigint; // Target: Growing
  badDebt: bigint; // Target: <1% of assets
}

Complete Deployment Example

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {IFluxVaultFactory} from "flux-v1-contracts/interfaces/IFluxVaultFactory.sol";
import {IStrategyFactory, StrategyParams} from "flux-v1-contracts/interfaces/IStrategyFactory.sol";
import {IAssetWrapperFactory} from "flux-v1-contracts/interfaces/IAssetWrapperFactory.sol";

contract VaultDeployer {
    IFluxVaultFactory public immutable vaultFactory;
    IStrategyFactory public immutable strategyFactory;
    IAssetWrapperFactory public immutable wrapperFactory;

    event VaultDeployed(
        address indexed vault,
        address indexed strategy,
        address indexed creator,
        string name
    );

    constructor(
        address _vaultFactory,
        address _strategyFactory,
        address _wrapperFactory
    ) {
        vaultFactory = IFluxVaultFactory(_vaultFactory);
        strategyFactory = IStrategyFactory(_strategyFactory);
        wrapperFactory = IAssetWrapperFactory(_wrapperFactory);
    }

    function deployCompleteVault(
        address baseAsset,
        address[] memory allowedAssets,
        StrategyParams memory params,
        string memory name,
        string memory symbol,
        bool immutableStrategy
    ) external returns (address vault, address strategy) {
        // 1. Deploy strategy
        if (immutableStrategy) {
            strategy = strategyFactory.deployImmutableStrategy(allowedAssets, params);
        } else {
            strategy = strategyFactory.deployMutableStrategy(
                allowedAssets,
                params,
                msg.sender
            );
        }

        // 2. Get or deploy base asset wrapper
        address baseAssetWrapper = wrapperFactory.getWrapper(baseAsset);
        if (baseAssetWrapper == address(0)) {
            baseAssetWrapper = wrapperFactory.deployERC20Wrapper(baseAsset);
        }

        // 3. Deploy vault
        vault = vaultFactory.createVault(
            IERC20(baseAsset),
            IAsset(baseAssetWrapper),
            IStrategy(strategy),
            IAccessPolicy(address(0)),  // Permissionless
            name,
            symbol
        );

        emit VaultDeployed(vault, strategy, msg.sender, name);
    }
}

---

Next Steps

Learn More:

• Strategy Selection Guide

• Risk Management

• Vault Concepts

• MetaVaults