vaea-flash-sdk 0.1.0

VAEA Flash — Universal Flash Loan SDK for Solana. Borrow any SPL token atomically in one call.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

# VAEA Flash SDK (Rust)

**Universal Flash Loan SDK for Solana** — Borrow any SPL token atomically in one call.

[![Crates.io](https://img.shields.io/crates/v/vaea-flash-sdk.svg)](https://crates.io/crates/vaea-flash-sdk)
[![Docs.rs](https://docs.rs/vaea-flash-sdk/badge.svg)](https://docs.rs/vaea-flash-sdk)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)

## Features

- **83+ tokens** — SOL, USDC, JitoSOL, mSOL, JUP, and 78 more
- **3 protocols** — Marginfi, Kamino, Jupiter Lend
- **Smart Router (VTE)** — Automatically finds cheapest route
- **Local Builder** — Build instructions in <0.1ms, zero HTTP
- **Jito Bundle** — Native MEV protection support
- **Profitability Check** — Verify profit before execution
- **Multi-token** — Atomic multi-asset flash loans

## Quick Start

```toml
[dependencies]
vaea-flash-sdk = "0.1"
```

```rust
use vaea_flash_sdk::{VaeaFlash, BorrowParams};
use solana_sdk::signature::Keypair;

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

    // Check available liquidity
    let capacity = flash.get_capacity().await?;
    let sol = capacity.tokens.iter().find(|t| t.symbol == "SOL").unwrap();
    println!("SOL available: {} ({})", sol.max_amount, sol.source_protocol);

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

    // Build flash loan instructions
    let ixs = flash.borrow(&BorrowParams {
        token: "SOL".to_string(),
        amount: 1000.0,
        instructions: vec![/* your arb instructions */],
        slippage_bps: None,
        max_fee_bps: Some(5), // 0.05% max fee guard
    }).await?;

    println!("Built {} instructions", ixs.len());
    Ok(())
}
```

## Zero-HTTP Local Builder

For latency-critical bots, build instructions in **<0.1ms** with zero network calls:

```rust
use vaea_flash_sdk::{localBuild, LocalBuildParams, FlashTier, syncRegistry};

// Sync token registry once at startup
sync_registry(None).await;

// Build locally — 0.1ms, no HTTP
let result = local_build(LocalBuildParams {
    payer: wallet.pubkey(),
    token: "SOL".into(),
    amount: 1000.0,
    tier: FlashTier::Sdk,
})?;

// result.begin_flash + [your IXs] + result.end_flash
```

## API Methods

| Method | Description |
|--------|-------------|
| `get_capacity()` | Real-time liquidity across 83+ tokens |
| `get_quote(token, amount)` | Fee breakdown with VTE routing |
| `build(request)` | Get prefix/suffix instructions from API |
| `borrow(params)` | Build complete flash loan instructions |
| `borrow_local(params)` | Same as borrow, zero HTTP (<0.1ms) |
| `execute(params)` | Build + sign + send in one call |
| `execute_local(params)` | Same as execute, zero HTTP |
| `execute_smart(params)` | Smart routing with local fallback |
| `simulate(params)` | Dry-run simulation |
| `borrow_multi(params)` | Multi-token atomic flash loans |
| `is_profitable(params)` | Pre-execution profitability check |
| `read_flash_state(payer, mint)` | Read on-chain FlashState PDA |
| `get_route(token, amount, max_bps)` | VTE smart route resolution |
| `get_health()` | System health check |
| `get_matrix()` | Full liquidity matrix |
| `get_discovery()` | Token discovery summary |

## License

MIT — see [LICENSE](LICENSE)