Solana · High-frequency arbitrage

Atomic arbitrage,
engineered for the chain.

Nano Trading Labs builds and operates custom on-chain Solana programs that capture price dislocations across decentralized markets — executed atomically, in milliseconds, from infrastructure placed beside Jito's block engines.

Explore services → Talk to the desk
rustanchorjito bundlesflash liquidity3 regions
spread_monitor — venue_a ⇄ venue_b SIMULATION
Spread0.0 bps
Threshold6.0 bps
Routes fired0
Last route—
3Colocated regions
AMS · FRA · NYC
0.135msRound-trip to Jito
block engine · AMS
1.80msRound-trip to Jito
block engine · NYC
24/7Automated monitoring
& alerting

Latency: round-trip from our hosts to the nearest Jito block engine, October 2026. Varies with network conditions.

01 — What we do

Strategy logic that lives
on the chain itself.

Most bots decide off-chain and hope the market waits. Our programs check the edge inside the transaction — so a route either captures it or never happens.

01PROGRAMS

Custom on-chain programs

Purpose-built Rust programs deployed directly on Solana. Every step of a route runs in one instruction flow — nothing to front-run between legs.

rustanchorsbf
02EXECUTION

Atomic, all-or-nothing

Each route borrows, swaps and repays inside a single transaction. If the edge is gone at execution, the whole thing reverts and nothing settles.

flash liquidityrevert-on-loss
03INFRASTRUCTURE

Colocated beside Jito

Execution hosts in Amsterdam, Frankfurt and New York — each sub-millisecond to low-millisecond from a Jito block engine, so bundles reach the leader first.

jitobundlesmulti-region
02 — Execution pipeline

From signal to settlement in a single slot.

A Solana slot is roughly 400 milliseconds. Everything below is designed to fit inside one.

01

DETECT

Stream pool state across venues and score price dislocations continuously.

// continuous
02

SIMULATE

Simulate each candidate route against live state — net of fees, slippage and tip.

// pre-trade
03

BUNDLE

Pack profitable routes into one atomic transaction and sign it.

// microseconds
04

LAND

Submit to the nearest Jito block engine for inclusion by the current leader.

// target: same slot
05

SETTLE

Flat by the end of the transaction. Every result is logged and reconciled.

// on-chain, final
programs/route/src/lib.rsILLUSTRATIVE
// atomic two-venue route — every leg or none
pub fn execute(ctx: Context<Route>, size: u64) -> Result<()> {
    let loan = flash::borrow(&ctx, size)?;        // 1 borrow
    let out  = venue_a::swap(&ctx, loan, Buy)?;   // 2 buy low
    let back = venue_b::swap(&ctx, out, Sell)?;   // 3 sell high
    let cost = loan + fees(&ctx);
    require!(back > cost, Error::NoEdge);       // 4 no edge → revert
    flash::repay(&ctx, cost)?;                    // 5 repay
    emit!(Settled { pnl: back - cost });
    Ok(())
}
03 — Infrastructure

Three regions.
One execution fabric.

view infrastructure →
05 — Risk architecture

Risk is engineered,
not hoped away.

Atomic or nothing

Routes that can't clear their costs revert before they settle. A failed attempt costs, at most, a network fee.

Bounded exposure

Per-route size limits, loan caps and pre-trade balance checks on every run — enforced in code, not by memory.

Watched around the clock

Automated health checks on every host, program and endpoint, with alerts to the desk within minutes.

Emergency isolation

A single command isolates funds into a secure wallet and locks down reporting — and can be fully reversed.

Get in touch

Ready when the market is.

Tell us what you're building or trading. We reply to every inquiry, usually within one business day.

Contact us → Read the FAQ