Solana MEV is the profit validators and specialized traders can capture by controlling the order in which transactions land in a block. Most of it flows through one piece of infrastructure, Jito, and most of it is harmless arbitrage. The part that hurts ordinary users is the sandwich attack, and that is the part you can actually defend against.
This guide explains where the value comes from, how Jito and its newer Block Assembly Marketplace shape the market, how sandwich attacks drain DEX traders, and the concrete settings and tools that keep your swaps out of a bot’s crosshairs.
How MEV works on Solana
MEV stands for maximal extractable value: the extra profit someone can earn by choosing the order, inclusion, or position of transactions in a block. On Solana, the validator producing the current block decides that order, so whoever influences the sequence can insert, reorder, or sandwich trades for gain.
Solana works differently from Ethereum here, and the difference matters. Ethereum transactions sit in a public mempool where anyone can watch and bid on them before they confirm. Solana has no traditional public mempool. Validators take turns as “leader” on a deterministic schedule, and users send transactions straight to the upcoming leader rather than into a shared waiting room.
If there’s no mempool, why does MEV still happen?
Because pending transactions are still observable, just through different channels. Traders stream transaction data from leaders, relays, and low-latency feeds, which gives bots enough visibility to act before a swap settles. Jito’s block engine added a structured auction on top of this flow, turning raw speed into an organized market for block space.
So the mempool is gone, but the opportunity is not. Removing the public staging area narrowed the attack surface without closing it.
The main types of value extraction
Not all MEV is predatory. On Solana it usually falls into four buckets:
- Arbitrage — bots correct price gaps between DEXs, often inside a single atomic transaction. This is the bulk of activity and is mostly benign; it tightens prices.
- Liquidations — bots repay undercollateralized loans to claim the liquidation bonus, which keeps lending markets solvent.
- Liquidity sniping — bots race to be first into a new pool or token launch.
- Sandwich attacks — bots detect your pending swap, buy ahead of you, let your trade push the price up, then sell. This is the harmful kind, and it comes straight out of the user’s pocket.
The first three keep markets efficient. The fourth is what the ecosystem has spent the last two years trying to stamp out.
Jito: the infrastructure behind most Solana MEV
Jito is the dominant MEV layer on Solana. Jito Labs maintains a modified validator client (Jito-Solana) and an off-chain auction that together handle the vast majority of the network’s MEV flow — the company reports its block engine reaches around 98% of total stake, and its validator-client family runs a majority of active stake (Jito Q2 2026 report).
What are Jito bundles and tips?
A bundle is a group of up to five transactions that execute atomically and in order — all of them land, or none do. Searchers submit bundles to Jito’s block engine with a SOL tip, and the engine runs an auction, ranking bundles by tip relative to the compute they use and forwarding the winners to the validator building the block.
Two points clear up a common mix-up. A priority fee is paid to the network to jump the queue during congestion; a Jito tip is a direct SOL payment to the validator for including your bundle. Tips are only charged if the bundle actually executes, and by 2026 they account for more than 60% of all priority-fee volume on Solana (Chainstack). Because bundled transactions stay private until they are included, bundles double as a shield: an attacker can’t sandwich what they can’t see in advance.
BAM: Jito’s Block Assembly Marketplace
BAM is Jito’s next-generation block-building system, and it is the biggest structural change to Solana MEV in years. It launched on mainnet in late September 2025, replacing the old closed-source block engine with an open-source framework.
The mechanics are what make it interesting. BAM runs its scheduler inside a trusted execution environment — a secure enclave where transaction contents stay encrypted even from the operator — so pending trades aren’t exposed to the party ordering them. That encrypted path removes the primary vector for sandwich attacks, and it lets applications define their own ordering rules through plugins, a feature Jito calls application-controlled execution. By mid-2026, BAM was running on roughly a third of network stake.
The ambition goes beyond protection. Drift co-founder Cindy Leow said BAM could help Solana finally become an “onchain NASDAQ” — fast, programmable markets where order books and derivatives behave the way professional traders expect.
Solana sandwich attacks: how they drain traders
A sandwich attack brackets your trade with two of the attacker’s own. Here is the sequence on a DEX swap:
- You submit a buy for Token X with, say, 5% slippage tolerance.
- A bot spots it, buys Token X first, and pushes the price up.
- Your order fills at that worse price, pushing it higher still.
- The bot sells into your order and pockets the spread.
You still get your tokens, just fewer of them than you should have. The gap is the attacker’s profit, and the loose slippage you set is what made the attack worth running.
The numbers are not small. Research presented at Accelerate 2025 estimated that sandwich bots extracted between $370 million and $500 million from Solana users over the 16 months from January 2024 to May 2025, with roughly 0.72% of all blocks containing a sandwich. Retail DEX trades and low-liquidity meme coins take the worst of it.
The ecosystem fought back in 2025
The response was coordinated, and it worked. After Jito removed its public mempool in March 2024, some validators spun up private mempools to keep sandwiching, so the Solana Foundation cut financial support to validators running them. Jito has since banned validators caught sandwiching — including a batch of 15 removed in October 2025 for multi-slot “wide sandwich” attacks. Staking protocol Marinade Finance blacklisted more than 50 validators through its Stake Auction Marketplace, protecting over $2 billion in delegated stake.
Together, these moves cut sandwich profitability by an estimated 60–70% across 2025. The attacks aren’t gone, but they’re a smaller, riskier business than they were.
Solana MEV bots: what they are and how they work
A Solana MEV bot is automated software that scans network activity for profitable ordering opportunities and acts on them in milliseconds. The operators are called searchers. A typical run looks the same whether the strategy is arbitrage or something nastier: detect the opportunity, assemble a bundle, attach a tip, submit it to the block engine, and win the auction so the bundle lands in the right spot.
The barrier to entry is latency, not code. A competitive solana mev bot needs to see transaction data and reach the leader faster than its rivals, which is why serious operators obsess over infrastructure placement and fast data feeds. The majority of this bot activity is benign arbitrage; the same toolkit, pointed at retail swaps, becomes a sandwich operation.
How to protect your transactions from MEV on Solana
You can’t stop MEV from existing, but you can make your own transactions a bad target. These are the defenses that actually move the needle, roughly in order of impact.
1. Tighten your slippage
Slippage is the single most effective lever you control. Solana’s own MEV protection guide calls a tight slippage tolerance the best defense, because a narrow window leaves an attacker almost no margin to extract. As a rough baseline: 0.1–0.3% on stablecoin pairs, a few percent at most on volatile tokens, and never a blanket “auto” setting on large trades, since auto often picks a wider band than you need. Tools like Jupiter offer dynamic slippage that sizes the window to current liquidity.
2. Route transactions privately
Keep your trade out of sight until it executes. In practice that means:
- Enabling MEV Protect in Jupiter’s swap settings, which routes through Jito by default.
- Sending swaps as Jito bundles, optionally with the
dontfrontfeature, so they can’t be front-run. - Using trading terminals that submit through MEV-protected paths rather than broadcasting openly.
3. Mind your endpoint
Your submission path matters more than most traders realize. When you send a transaction, your RPC provider sees it before the validator does, and a slow or leaky endpoint can expose or delay your trade. A reliable provider that lands transactions quickly reduces both the window and the odds that your order is seen by the wrong party.
This is where NOWNodes fits naturally. It offers Solana RPC and WebSocket endpoints — mainnet and testnet, with archive and trace access — behind a single API across 120+ networks, with a reported 99.95% uptime and sub-second average response times. For builders wiring up a bot, a wallet, or a DEX front end, fast and dependable submission infrastructure is part of the MEV defense, not a separate concern. Testing your flow on Solana’s testnet before going live is a sensible first step.
4. Size and split trades sensibly
Large orders on thin pools are the easiest to sandwich. Trading liquid pairs, breaking big swaps into smaller pieces, and avoiding low-liquidity launches all shrink the profit an attacker could capture.
Here’s how the paths compare:
| Standard transaction | MEV-protected (Jito bundle / Jupiter MEV Protect) | |
|---|---|---|
| Visibility before execution | Observable via leader/relay feeds | Private until included |
| Sandwich protection | None | Strong |
| Extra cost | Priority fee only | Priority fee + Jito tip |
| Best for | Simple transfers, low-MEV actions | DEX swaps, anything price-sensitive |
Where this is heading
The structural picture is improving. Most Solana MEV is still ordinary arbitrage that keeps prices honest, and the predatory slice has been squeezed by validator bans, staking-side pressure, and above all by BAM’s encrypted, programmable block building. Faster upgrades like Alpenglow and the Firedancer client will speed up execution — which helps everyone, bots included — but the encrypted-mempool approach is what directly shrinks the sandwich surface.
For a trader, the takeaway is simple and actionable: tighten slippage, route privately, use solid submission infrastructure, and size trades for the liquidity that’s actually there. For a builder, the same discipline applies at the infrastructure layer. MEV isn’t a bug you can delete, but on Solana in 2026 it’s a risk you can manage.
FAQ
Is all MEV on Solana harmful?
No. The majority is arbitrage and liquidations, which keep prices aligned across DEXs and lending markets solvent. Sandwich attacks are the harmful exception, and they target price-sensitive DEX swaps rather than simple transfers.
Can I recover funds lost to a sandwich attack?
No. Once a block is finalized, the trade is settled and irreversible. There’s no refund mechanism, which is exactly why prevention — mainly tight slippage and private routing — is the only real protection.
Does using Jito guarantee I won’t be sandwiched?
Submitting through Jito bundles or Jupiter’s MEV Protect makes sandwiching very difficult, because your trade stays private until it executes. It’s protection, not an absolute guarantee, and the same Jito infrastructure has historically been used by attackers too — which is partly what BAM’s encrypted design aims to fix.
Will Firedancer and Alpenglow stop MEV?
Not on their own. More throughput and faster finality reduce congestion and competition for block space, but they also let bots act faster. The upgrades making the biggest dent in predatory MEV are BAM and its encrypted mempool, not raw speed.
Is running a Solana MEV bot worth it?
For most people, no. Profitable operation depends on low-latency infrastructure and constant competition against well-funded searchers, and the easy sandwich profits of 2024 have largely dried up under ecosystem pressure. Arbitrage remains viable but is a crowded, latency-driven game.
