Addresses

This page lists all deployed Flux Protocol contracts across different networks.

Mainnet Deployments

Note: Flux Protocol is not yet deployed to mainnet. Check back soon for deployment addresses.

Core Protocol

Contract	Address	Verified
FluxVaultFactory	TBD	-
StrategyFactory	TBD	-
AssetWrapperFactory	TBD	-
FluxVaultLens	TBD	-
OracleRegistry	TBD	-

Governance

Contract	Address	Verified
Governance Multisig	TBD	-
Protocol Fee Collector	TBD	-
Timelock Controller	TBD	-

---

Testnet Deployments

Base Sepolia

Contract	Address	Verified
FluxVaultFactory	TBD	-
StrategyFactory	TBD	-
AssetWrapperFactory	TBD	-
FluxVaultLens	TBD	-
OracleRegistry	TBD	-

Explorer: Base Sepolia Explorer

Sepolia (Ethereum Testnet)

Contract	Address	Verified
FluxVaultFactory	TBD	-
StrategyFactory	TBD	-
AssetWrapperFactory	TBD	-
FluxVaultLens	TBD	-
OracleRegistry	TBD	-

Explorer: Sepolia Explorer

---

Example Vaults

Mainnet Example Vaults

Coming soon after mainnet launch

Testnet Example Vaults (Base Sepolia)

Vault Name	Base Asset	Strategy	Address	Verified
Example USDC Vault	USDC	Immutable (10% APR)	TBD	-
Example WETH Vault	WETH	Mutable (8% APR)	TBD	-

---

Asset Wrappers

Mainnet Wrappers

Coming soon

Testnet Wrappers (Base Sepolia)

Asset	Wrapper Type	Address	Verified
USDC	ERC20	TBD	-
WETH	ERC20	TBD	-
DAI	ERC20	TBD	-

---

Strategies

Mainnet Strategies

Coming soon

Testnet Strategies (Base Sepolia)

Strategy	Type	Annual Rate	Curator Fee	Address	Verified
Conservative USDC	Immutable	6%	5%	TBD	-
Balanced WETH	Mutable	10%	10%	TBD	-

---

Integration Addresses

For testing and development, you can deploy your own instances or use the testnet addresses above.

Required Contracts for Integration

To integrate with Flux, you need to interact with:

1. FluxVaultFactory - Create vaults, register executors

2. StrategyFactory - Deploy strategies (optional, can use existing)

3. AssetWrapperFactory - Deploy wrappers (optional, can use existing)

4. FluxVaultLens - Query vault/manager state

5. Individual Vaults - Deposit, withdraw, borrow operations

Quick Start (Testnet)

// Connect to factory
IFluxVaultFactory factory = IFluxVaultFactory(FACTORY_ADDRESS);

// Check if vault exists
bool isVault = factory.isVault(vaultAddress);

// Register executor
address executor = factory.deployWeirollExecutor();
factory.registerExecutor(msg.sender, executor);

// Interact with vault
IFluxVault vault = IFluxVault(vaultAddress);
vault.deposit(amount, receiver);

---

Contract Verification

All contracts are verified on their respective block explorers. You can:

1. View Source Code - See the exact code that's deployed

2. Verify Interactions - Understand what functions do

3. Check Constructor Args - See deployment parameters

4. Read Contract State - Query public variables

Verifying a Contract

If you deploy your own contracts, verify them using:

# Using Foundry
forge verify-contract \
    --chain-id 84532 \
    --watch \
    --constructor-args $(cast abi-encode "constructor(address)" $FACTORY_ADDRESS) \
    $CONTRACT_ADDRESS \
    src/FluxVault.sol:FluxVault

# Using Hardhat
npx hardhat verify --network baseSepolia $CONTRACT_ADDRESS $CONSTRUCTOR_ARG

---

ABI Files

Accessing ABIs

Option 1: From npm package

npm install @flux-protocol/contracts

import FluxVaultABI from '@flux-protocol/contracts/abi/FluxVault.json';
import FluxVaultFactoryABI from '@flux-protocol/contracts/abi/FluxVaultFactory.json';

Option 2: From GitHub

https://github.com/nexus-labs/flux-v1-contracts/tree/main/out

Option 3: From block explorer

Visit any verified contract on the block explorer and navigate to the "Contract" tab to download the ABI.

Key ABIs

Contract	ABI Location	Description
IFluxVault	out/IFluxVault.sol/IFluxVault.json	Core vault interface
IFluxVaultFactory	out/IFluxVaultFactory.sol/IFluxVaultFactory.json	Factory interface
IStrategy	out/IStrategy.sol/IStrategy.json	Strategy interface
IAsset	out/IAsset.sol/IAsset.json	Wrapper interface

---

Using Contract Addresses

TypeScript/JavaScript Example

import { ethers } from 'ethers';
import FluxVaultABI from '@flux-protocol/contracts/abi/FluxVault.json';

// Connect to Base Sepolia
const provider = new ethers.JsonRpcProvider('https://sepolia.base.org');

// Load vault contract
const VAULT_ADDRESS = '0x...'; // From table above
const vault = new ethers.Contract(VAULT_ADDRESS, FluxVaultABI, provider);

// Read vault state
const totalAssets = await vault.totalAssets();
const sharePrice = await vault.convertToAssets(ethers.parseEther('1'));

console.log('Total Assets:', ethers.formatUnits(totalAssets, 6));
console.log('Share Price:', ethers.formatEther(sharePrice));

Solidity Example

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

import {IFluxVault} from "@flux-protocol/contracts/interfaces/IFluxVault.sol";
import {IFluxVaultFactory} from "@flux-protocol/contracts/interfaces/IFluxVaultFactory.sol";

contract MyFluxIntegration {
    // Hardcode addresses from table above
    IFluxVaultFactory constant FACTORY = IFluxVaultFactory(0x...);
    IFluxVault constant VAULT = IFluxVault(0x...);

    function depositToFlux(uint256 amount) external {
        // Approve vault
        IERC20(VAULT.asset()).approve(address(VAULT), amount);

        // Deposit
        uint256 shares = VAULT.deposit(amount, msg.sender);
    }
}

Python Example (web3.py)

from web3 import Web3
import json

# Connect to Base Sepolia
w3 = Web3(Web3.HTTPProvider('https://sepolia.base.org'))

# Load contract
VAULT_ADDRESS = '0x...'  # From table above
with open('FluxVault.abi.json') as f:
    VAULT_ABI = json.load(f)

vault = w3.eth.contract(address=VAULT_ADDRESS, abi=VAULT_ABI)

# Read state
total_assets = vault.functions.totalAssets().call()
share_price = vault.functions.convertToAssets(10**18).call()