I Shipped AURA: A Production-Grade Multi-Path `sendTransaction` Router for Solana MEV-Sensitive Flows

After 4 months of intense building, I finally shipped AURA — a production-grade Solana transaction routing service engineered from the ground up for maximum landing probability on MEV-sensitive flows.

This isn’t another wrapper around a public RPC.

This is a sub-slot optimized, multi-path fanout proxy that treats every millisecond like it matters — because on Solana, it does.

Here’s what AURA actually does in production:

How AURA Works (The 10,000-Foot View)

You POST a signed transaction (raw bytes or full JSON-RPC payload) to one of our regional endpoints:

• FRA — Europe
• AMS — Europe (backup)
• NYC — North America

AURA instantly fans the transaction out across multiple competing execution paths in parallel:

• Direct staked QUIC via our own SWQOS relays (multiple leaders ahead + UDP fallback)
• Jito bundles with intelligent 80/20 tip forwarding + wallet pooling
• AuraProtect anti-frontrunning bundles (opt-in)
• RPC safety net as a non-blocking fallback

First arrival wins.

SWQOS deduplicates automatically.

We track full landing telemetry in Postgres with precise slot attribution.

The result? Dramatically higher landing rates on high-value, time-sensitive transactions where traditional routers bleed edge.

Core Technical Highlights (The Parts I’m Most Proud Of)

1. Rust + Tokio/Axum Single-Binary Proxy (Per Region)

Everything runs as a lean, single-binary service per region. No Python, no Node, no bloat.

// Simplified inbound handler
#[axum::debug_handler]
async fn handle_tx(
    State(state): State<Arc<AppState>>,
    JsonOrRawTx(payload): JsonOrRawTx,
) -> Result<Json<TxResponse>> {
    let tx_sig = extract_signature(&payload)?;

    // Fire-and-forget fanout — never block the hot path
    tokio::spawn(fanout_to_all_paths(state.clone(), payload, tx_sig));

    Ok(Json(TxResponse { status: "routed" }))
}

2. Per-Key Rate Limiting + Tip-Priority Queuing

We use DashMap + BinaryHeap + Condvar for lock-free, high-contention priority queuing.

• Per-key (wallet/pubkey) rate limits
• Dynamic tip priority queuing
• Zero-copy where possible

3. Full QUIC Stack

• Inbound: Custom QUIC server built with quinn
• Outbound: solana-quic-client talking directly to staked identities

Connection warming, region-aware leader scheduling, and intelligent fallback to UDP when QUIC handshakes fail.

4. Real-Time Observability Without Hot-Path Latency

This was the hardest part.

• Background landing checker + backfill
• On-chain tip attribution
• Fire-and-forget Postgres writes (centralized dashboard)
• Real-time SlotTracker + signature deduplication

The hot path never waits on DB. Telemetry is written asynchronously so latency stays in the sub-millisecond range.

5. Smart Jito Routing Logic

• Region proximity awareness
• Connection warming
• UUID cooldowns to prevent duplicate bundle spam
• Intelligent 80/20 tip splitting + wallet pooling

Why This Matters in 2026

Solana’s block production is getting faster. MEV is getting more sophisticated. The difference between landing and getting frontrun is increasingly measured in single-digit milliseconds.
Most open-source routers and public RPCs simply cannot compete with a purpose-built, multi-path, observability-first system like AURA.
We’re now live, handling real volume, and the engineering feels rock-solid.
Extremely proud of what the team shipped.

solana, rust, mev, defi, blockchain, high-performance, quic, jito, solana-dev, sendtransaction, tokio, axum