Turbo Mode

Build flash loan instructions 100% locally in ~91µs — no API call, no HTTP, no network. 2,000× faster than a round-trip.

SDK Build + Send Latency

Time from "I want a flash loan" to "TX is sent to the network". On-chain confirmation (~400ms/slot) is the same for everyone.

Mode	RPC Calls Before Send	IX Build Time	Send-to-Network
VAEA Turbo	2 (blockhash + send)	~91µs	~100ms
VAEA Standard	3 (API + blockhash + send)	~5ms	~180ms
Direct Marginfi SDK	5+ (banks, vaults, oracles, blockhash, send)	~20ms	~300-500ms
Direct Kamino SDK	4+ (reserves, oracles, blockhash, send)	~15ms	~250-400ms

ℹ️ Note

VAEA Turbo is faster because the VAEA SDK pre-resolves all protocol accounts (Marginfi banks, vaults, oracles) into a hardcoded local registry. Direct SDKs must fetch these accounts via RPC on every call because their state changes. The actual on-chain execution uses the same protocols — the speed gain is in TX construction, not execution.

Code Examples

// Turbo mode — zero API calls, ~91µs build
const sig = await flash.executeLocal({
  token: 'SOL',
  amount: 1000,
  onFunds: async (ixs) => {
    ixs.push(buyInstruction);
    ixs.push(sellInstruction);
    return ixs;
  },
});

How It Works

The SDK contains a hardcoded token registry and replicates the backend's instruction builder locally:

PDA derivation — computes flash vault, user state, config accounts
Account resolution — derives token accounts, ATAs, lookup table addresses
Instruction assembly — builds the borrow → your IXs → repay sandwich

localBuild() API

For full control, use localBuild() to get raw instructions without executing:

typescript

import { localBuild, VAEA_LOOKUP_TABLE } from '@vaea/flash';
import { TransactionMessage, VersionedTransaction } from '@solana/web3.js';

// ~0.09ms — builds begin_flash + end_flash instructions
const { beginFlash, endFlash, expectedFeeNative } = localBuild({
  payer: wallet.publicKey,
  token: 'SOL',
  amount: 1000,
});

// Build your own VersionedTransaction
const { blockhash } = await connection.getLatestBlockhash();
const message = new TransactionMessage({
  payerKey: wallet.publicKey,
  recentBlockhash: blockhash,
  instructions: [beginFlash, myArbIx, endFlash],
}).compileToV0Message([VAEA_LOOKUP_TABLE]);

const tx = new VersionedTransaction(message);
tx.sign([wallet]);
const sig = await connection.sendTransaction(tx, { skipPreflight: true });

When to Use

Criteria	Turbo (executeLocal)	Standard (execute)
Speed	~100ms	~180ms
API dependency	None	VAEA API required
Offline capable	✅ Yes	❌ No
Route updates	❌ Uses cached registry	✅ Always fresh
Best for	Bots, HFT, production	General use, prototyping

💡 Tip

Pre-warm with flash.warmCache() at boot for even faster first execution. Combine with sendVia: 'jito' for private MEV-protected execution.

borrowLocal() vs executeLocal()

Two levels of control — choose based on how much you want the SDK to handle:

Method	Returns	Sends TX?	Use Case
`borrowLocal(params)`	`TransactionInstruction[]`	❌ No	Get instructions — you build, sign, send
`executeLocal(params, opts)`	`string` (tx signature)	✅ Yes	One-liner: build + sign + send + confirm

typescript

// borrowLocal() — full control over the transaction
const ixs = await flash.borrowLocal({
  token: 'SOL', amount: 1000,
  onFunds: async () => [myArbIx],
});
// ixs = [beginFlash, myArbIx, endFlash]
// → Build your own VersionedTransaction, add compute budget, sign, send

// executeLocal() — one-liner, SDK handles everything
const sig = await flash.executeLocal({
  token: 'SOL', amount: 1000,
  onFunds: async () => [myArbIx],
}, { priorityMicroLamports: 5000 });