Struct VaeaFlash 

pub struct VaeaFlash { /* private fields */ }

VAEA Flash — Universal Flash Loan SDK for Solana (Rust)

Example

use vaea_flash::{VaeaFlash, BorrowParams, VaeaConfig, Source};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let payer = solana_sdk::signature::Keypair::new();
    let flash = VaeaFlash::new("https://api.devnet.vaea.fi", &payer)?;

    let capacity = flash.get_capacity().await?;
    println!("Available tokens: {}", capacity.tokens.len());

    let quote = flash.get_quote("SOL", 1000.0).await?;
    println!("Fee: {}%", quote.fee_breakdown.total_fee_pct);
    Ok(())
}

Implementations

impl VaeaFlash

pub fn new(api_url: &str, payer: &Keypair) -> Result<Self, VaeaError>

Create a new VaeaFlash client.

pub fn with_rpc( api_url: &str, rpc_url: &str, payer: &Keypair, ) -> Result<Self, VaeaError>

Create with full config including RPC for execute().

pub fn read_only(api_url: &str) -> Self

Create a read-only client (no wallet, no execute).

pub fn with_source(self, source: Source) -> Self

Set fee source (sdk or ui).

pub async fn get_capacity(&self) -> Result<CapacityResponse, VaeaError>

Get real-time capacity for all dynamically discovered tokens (120+).

pub async fn get_quote( &self, token: &str, amount: f64, ) -> Result<QuoteResponse, VaeaError>

Get a detailed quote with fee breakdown.

pub async fn build( &self, request: &BuildRequest, ) -> Result<BuildResponse, VaeaError>

Build prefix + suffix instructions for a flash loan.

pub async fn get_health(&self) -> Result<HealthResponse, VaeaError>

Check system health.

pub async fn get_matrix(&self) -> Result<MatrixResponse, VaeaError>

Get the full liquidity matrix — per-protocol per-token available liquidity.

pub async fn get_discovery(&self) -> Result<DiscoverySummary, VaeaError>

Get discovery summary — how many tokens were found during boot-time scanning.

pub async fn get_route( &self, token: &str, amount: f64, max_fee_bps: u16, ) -> Result<ResolvedRoute, VaeaError>

Resolve the optimal flash loan route for any supported token.

The Smart Router evaluates all direct routes across Marginfi, Kamino, and Jupiter Lend, then returns the cheapest feasible path.

pub async fn get_sources(&self) -> Result<SourcesResponse, VaeaError>

Get information about all supported lending protocols.

pub async fn get_aggregated_capacity( &self, ) -> Result<AggregatedCapacityResponse, VaeaError>

Get capacity breakdown per source (Marginfi, Kamino, Jupiter Lend) for each token.

pub async fn borrow( &self, params: &BorrowParams, ) -> Result<Vec<Instruction>, VaeaError>

Build flash loan instructions with user instructions sandwiched.

pub async fn execute(&self, params: BorrowParams) -> Result<String, VaeaError>

Build, sign, and send a flash loan transaction. Automatically uses the VAEA Address Lookup Table for TX compression.

pub async fn simulate( &self, params: &BorrowParams, ) -> Result<SimulateResult, VaeaError>

Simulate a flash loan transaction without sending it. Returns success/failure, CU consumption, and program logs.

pub async fn borrow_multi( &self, params: &BorrowMultiParams, ) -> Result<Vec<Instruction>, VaeaError>

Build a multi-token atomic flash loan with nested sandwich pattern: prefix_A → prefix_B → [user IXs] → suffix_B → suffix_A

pub async fn is_profitable( &self, params: &ProfitabilityParams, ) -> Result<ProfitabilityResult, VaeaError>

Check if a flash loan strategy is profitable after all fees.

pub fn borrow_local( &self, params: &BorrowParams, ) -> Result<Vec<Instruction>, VaeaError>

Build flash loan instructions 100% locally — NO API call.

~0.1ms vs ~80ms for borrow(). Use this for latency-critical bots. The instructions are identical to what /v1/build returns.

let ixs = flash.borrow_local(&BorrowParams {
    token: "SOL".to_string(),
    amount: 1000.0,
    instructions: vec![/* your arb IXs */],
    slippage_bps: None,
    max_fee_bps: None,
})?;

pub async fn execute_local( &self, params: BorrowParams, ) -> Result<String, VaeaError>

Build, sign, and send a flash loan in ~100ms — NO API call.

Uses local instruction building + direct RPC. Critical path: localBuild(<1ms) → getBlockhash(~50ms) → send(~50ms)

pub async fn execute_smart( &self, params: BorrowParams, ) -> Result<String, VaeaError>

Build, sign, and send a flash loan with intelligent route selection.

The Smart Router evaluates ALL available paths across Marginfi, Kamino, and Jupiter Lend, then selects the cheapest feasible route automatically. Falls back to execute_local() if the API is unavailable.

pub async fn read_flash_state( &self, payer_key: &Pubkey, token_mint: &Pubkey, ) -> Result<Option<FlashStateInfo>, VaeaError>

Read an active FlashState PDA from the chain.

Use this to verify a flash loan is active without CPI — just pass the PDA as a read-only account.

Cost: 1 RPC call (~5ms). On-chain equivalent: ~2K CU via vaea-flash-ctx crate.