Jito, MEV, Bundles
Suggest an editWhen a leader produces a block, they choose which transactions to include and in what order. That choice has value, because the right ordering can capture real profit from things like DEX arbitrage. The name for this profit is MEV: maximum extractable value. Jito is the system most of the Solana network uses to organize how MEV gets captured. It does this through two mechanisms, tips and bundles.
MEV is profit from choosing the order of transactions
Imagine a user is about to swap 100,000 USDC for SOL on a DEX. Their swap is large enough to move the price by half a percent, which on 100,000 USDC is 500 USDC. If you can spot their pending swap and buy SOL right before them, then sell right after, you pocket the half-percent move. They wanted to trade, and you made money from the fact that you knew about their trade and got to choose the order.
The profit comes from controlling transaction ordering. It exists in any system where somebody decides what goes in a block first, second, third. Solana has it just like every other chain does.
What differs on Solana is who can spot the pending swap. There is no public mempool to watch, as the architecture lesson explained: transactions go straight from RPC nodes to leaders via Gulf Stream. But the leader still sees every transaction they're about to include and still chooses the order, and a leader can also buy private order flow from RPC providers. So the MEV is still there, and it goes to whoever has the closest relationship with the leader.
Before Jito, MEV on Solana was opaque. Big trading firms ran their own validators or made informal deals with leaders, and ordinary users had no idea their transactions were being reordered around them. Jito turned this into an auction that anyone can bid in.
A tip is a payment for priority
A tip is a regular SOL transfer to one of eight special accounts that Jito designated. You add a SystemProgram::transfer to your transaction, sending some lamports to a Jito tip address, and it needs no special instruction, bundle, or API call.
Leaders running the Jito-Solana validator client watch for these transfers. When they're building a block, they prioritize transactions that include tips, ordered by how much was tipped.
The eight tip accounts exist for performance reasons. Solana's runtime serializes transactions that write to the same account, so if every tip went to one account, every tipped transaction in a block would block each other. With eight accounts, Jito-Solana spreads the load. Your client picks one at random for each transaction.
Tips are not the same as priority fees. They live alongside each other:
- Priority fees go to the leader as part of normal fee processing. Set via the ComputeBudget program.
- Jito tips go directly to the leader as a SOL transfer. Recognized only by Jito-Solana leaders.
A transaction can have both. Most production wallets and routers attach both, because together they maximize the chance the transaction lands.
A bundle lands several transactions together, in a fixed order
Some operations only make sense as a sequence. Inside one transaction that is already guaranteed: the instructions run in order, and if one of them fails, none of the changes happen, as instructions and transactions explained. The guarantee covers one transaction only. Two separate transactions can land one without the other, and nothing fixes which transaction lands right before yours or right after it.
A bundle is a small group of up to 5 transactions that the leader commits to including together, in the order you specify. If any transaction in the bundle fails, none of them land.
Take the swap from the first example. Your buy, the user's swap, and your sell are three transactions, and the swap is signed by the user, so you cannot put all three into one transaction of your own. A bundle lands them together and in that order, or not at all.
A searcher, meaning someone running a trading bot, submits the group of transactions to the Jito block engine, which is an off-chain service that runs an auction. The block engine has its own API endpoint, so bundles go to it directly rather than to RPC nodes. Bundles compete against each other for the same slot. The block engine picks winners based on tip size, simulates them to make sure they'd succeed, and forwards the winning bundles to the current leader. The leader, running Jito-Solana, places them in the block.
The tip works the same way as for single transactions: a SOL transfer to one of those eight tip accounts, included as one of the transactions in the bundle. If the bundle lands, the leader collects the tip. If the bundle fails or doesn't win the auction, no tip is paid.
Jito's guarantees depend on its own service and its own client
The auction is not part of the protocol. It runs in Jito's block engine, an off-chain service, so a bundle lands only if that service receives it and forwards it to the leader. Only leaders running the Jito-Solana client recognize tips and place bundles, so in a slot whose leader runs another client, a bundle cannot land. The same bundle mechanism that the searcher from the first example uses against a large swap can also protect it, as the next section shows.
What to do in your frontend and in your program
Bundles are mostly used by trading firms and MEV bots, and most developers never submit one. But Jito affects every Solana developer, because tips have become the standard way transactions get prioritized on the network.
Your users' transactions need tips to land reliably during busy periods. When the network is calm, a normal transaction with a small priority fee lands easily. When the network is busy, transactions without tips often get dropped while tipped ones go through. If you build a frontend that submits user transactions, you probably want to attach a Jito tip. Most wallet SDKs and transaction-building libraries support this directly.
A large swap can be routed through Jito so that nothing is inserted around it. When a user does a large swap on a DEX, MEV bots can profit by placing their own transactions around it, the pattern described at the start of this lesson. One defense is to route the user's transaction through Jito, often as part of a bundle that includes a "protection" component preventing other transactions from being inserted nearby. Aggregators like Jupiter do this when MEV protection is enabled, and the user pays a tip for it.
In your program, the swap instruction takes a limit. The program cannot control how a transaction was sent, but it controls which result it accepts. The user signs the minimum output they accept together with the swap, and the swap fails if the result is below it, as boundary of consent in the Solana Pro course shows with Jupiter. For the 100,000 USDC swap above, if the user signs a minimum 0.1% below the expected output, trading ahead of them can cost them at most about 100 USDC, and a worse result makes the swap fail. A tighter minimum leaves less to take but also fails the swap more often when the price moves for ordinary reasons, so the user picks the number and the instruction takes it as an argument.
Most developers get tips and bundle protection by using a wallet adapter or aggregator that already handles them internally. Knowing the mechanism is what lets you debug "why isn't my transaction landing" and "why did my user get a worse price than expected."