You already know the uncomfortable truth from the MEV course: when you sign a swap and broadcast it, you are the opportunity. Your transaction is the slab of meat the searchers smell. They build a bundle around it, the builder packs that bundle into the most profitable ordering, the validator picks the block that pays the biggest bribe, and the surplus — the value that only exists because you decided to trade — sails right past you. By the time the block is sealed, the MEV your order created has been split between a searcher, a builder, and a validator, none of whom you’ve ever met. You paid for the party and didn’t get a slice of cake.
The MEV course was largely about the first instinct: stop the bleeding. Hide the order, encrypt the mempool, route privately, make the opportunity hard to find. This course asks a sharper, almost cheeky question. The extraction is going to happen anyway — auctions are efficient, and someone will always be willing to pay for good ordering. So forget “make it disappear.” The real question is ownership: who should keep the value your order created, and can we build plumbing that routes it back to you? That pivot — from minimizing extraction to redistributing it — is the whole course. Welcome to the redistribution turn.
Before you read — take a guess
Today, on a typical public-mempool swap, who ends up keeping most of the MEV your transaction creates?
The four things you can do about MEV
Faced with MEV, the ecosystem has exactly four verbs. Think of MEV as the tip jar your transaction accidentally fills up at the front of the restaurant. You can do four things about that jar.
- Minimize — hide the jar. Encrypted mempools, private RPC endpoints, and threshold encryption keep your order secret until it’s too late to attack. If searchers can’t see the opportunity, they can’t price it. This is the MEV course’s home turf. The catch: privacy is leaky and partial, and you’re fighting a permanent arms race against people whose full-time job is finding what you hid.
- Capture — build a better jar so the restaurant collects tips cleanly. This is PBS (proposer–builder separation) and MEV-Boost: instead of validators clumsily extracting MEV themselves, a competitive builder market extracts it efficiently and pays the validator. It massively improves who captures it efficiently — but notice it’s the validator’s jar. You, the diner who generated the tip, still see nothing.
- Redistribute — give the tip back to the customer who created it. Recognize that the opportunity belongs to the user, sell the right to exploit it on their behalf, and refund the proceeds to them. This is what this course is about. The extraction still happens; the destination of the money changes.
- Democratize / decentralize — make the jar credibly neutral so no single waiter can rig who gets the tips. Build an ordering/auction layer no one party monopolizes — the SUAVE vision (Single Unifying Auction for Value Expression: a shared, decentralized sequencing and block-building network). We hit this in lesson 5. It’s less a fifth competing idea than the endgame that makes redistribution trustworthy at scale.
So: this course lives on the third verb — redistribute — and points at the fourth as the horizon. Here’s the four laid side by side.
| Strategy | Who keeps the value | Mechanism | What it costs you |
|---|---|---|---|
| Minimize | Nobody captures it (ideally) | Encrypted mempool, private RPC, hide the order | Latency, leaky privacy, a forever arms race |
| Capture | The validator (efficiently) | PBS / MEV-Boost builder auction | Nothing changes for you — value still flows up |
| Redistribute | The user who created it | Order-flow auction sells the right, refunds the user | You trust an auctioneer; extraction still happens |
| Democratize | Whoever the neutral market clears to | Decentralized sequencing (e.g. SUAVE) | Coordination cost, immature tooling |
Four verbs, one tip jar
Minimize hides the jar, Capture builds a cleaner jar for the restaurant, Redistribute hands the tip back to the diner, and Democratize makes sure no single waiter controls the jar. They stack — a redistribution system can also use privacy (minimize) and run on a neutral layer (democratize).
Pick a term, then click its definition.
Your order flow is an asset
Here’s the reframe that makes the rest of the course click: your order flow is a thing with measurable market value, and assets can be sold and the proceeds returned to their owner.
Order flow is just the stream of transactions a user (or a wallet, or an app) sends to the chain — the swaps, the trades, the intents to execute. The right to execute or back-run that flow is valuable, because it’s a privileged shot at the MEV the flow creates. In traditional finance this is old news: it’s called payment for order flow (PFOF), where a broker sells the right to fill your stock trades to a market maker. The dirty secret of PFOF is that the broker pockets the payment — you generate the flow, they get paid for it.
The supermarket analogy is cleaner and friendlier. Every time you shop, your basket generates valuable data and predictable demand. A middleman could quietly sell that and skim the proceeds — or the supermarket could hand you a loyalty cashback for the value your shopping creates. Redistribution is choosing the second model for blockchains: the value your order flow generates gets routed back to you, not skimmed by a middleman you never agreed to.
Make it concrete with tiny numbers. Suppose your swap creates a back-run opportunity worth $100 to whoever lands the trade right after you.
- Old world (status quo): the searcher who exploits it pays a bribe to the builder, the validator captures the bribe, and you receive $0 of the $100. The opportunity was yours; the money wasn’t.
- New world (redistribution): an order-flow auction runs first. Searchers bid for the exclusive right to back-run your trade; the top bid comes in at, say, $90. The auction keeps a small cut — say $5 — and refunds $85 straight back to you. You went from $0 to $85 of value you created, simply by selling the right instead of giving it away.
That $85 doesn’t fall from the sky — it’s the same $100 of extraction, just sent to a different address. The genius isn’t conjuring new value; it’s noticing the value was always yours to sell.
1. User / Wallet
Signs a transaction and broadcasts it — wanting it included, but with no say over where it lands in the block.
2. Searcher
Scans pending transactions for MEV (arbitrage, liquidations), then packages a profitable, precisely ordered bundle.
3. Builder
Assembles many bundles and transactions into a full, ordered block and computes how much it can pay to have it proposed.
4. Relay
Runs a sealed-bid auction: it holds builders’ blocks, escrows them, and exposes only the header + bid so no one can steal the order.
5. Proposer / Validator
Picks the highest-paying header and signs it — committing to a block it never saw the contents of, and pocketing the bid.
Step 1 of 5: User / Wallet. Signs a transaction and broadcasts it — wanting it included, but with no say over where it lands in the block.
The classic MEV-Boost pipeline. In the status quo, value travels left-to-right — away from you — and the validator captures it. Redistribution wedges an order-flow auction in at the very start (you / your wallet) so the proceeds get routed back down to where they were created, instead of accruing at the right end.
Why the user is the natural owner
Plenty of parties touch your transaction — wallet, RPC, searcher, builder, relay, validator. So why crown the user as the rightful owner of the value, rather than, say, the validator who does the work of including it? Four arguments, and they reinforce each other.
- (a) You create the opportunity. No swap, no back-run. The MEV is a derivative of your decision to trade — it literally cannot exist without your order. Ownership of a derivative tracking back to its source is about as clean a property claim as you’ll find on-chain.
- (b) It improves your effective price. A refund isn’t an abstract fairness win — it’s price improvement: the difference between the price you’d have gotten and the better price you actually get once the rebate lands. Get $85 back on a swap and you effectively traded at a better rate. Users feel that directly, even if they never learn the word “MEV.”
- (c) It realigns incentives. Here’s the elegant part. If the value of attacking your transaction flows back to you, then the marginal reason to attack you shrinks toward zero — the prize is being handed to its rightful owner instead of dangled in front of predators. Redistribution doesn’t just compensate you for the sandwich; it quietly defuses the motive to sandwich you.
- (d) Wallets and apps can negotiate at scale. One user’s single swap is a weak bargaining chip. But a wallet routing millions of swaps is a whale at the negotiating table — it can run a real auction, demand real refunds, and pass them to users automatically. Aggregated order flow is leverage, and aggregation is exactly what wallets and apps already do.
Fill in the core ownership argument for redistribution.
Pick the right option for each blank, then check.
The user is the natural owner of MEV because their transaction in the first place. Routing the proceeds back to them shows up as on their trade, and — crucially — it shrinks the incentive to , because the prize now goes to its rightful owner. At scale, can aggregate flow and negotiate refunds on the user's behalf.
Redistribution does not make MEV disappear
This is the misconception to kill early. Redistribution does not eliminate extraction — the back-run, the auction, the arbitrage all still happen. All it changes is who the auction pays. The money flows to you instead of past you. If you want extraction to actually stop, that’s the minimize verb (privacy/encryption), and it’s a different, much harder fight. Mixing the two up is the fastest way to misjudge what an order-flow auction is even promising.
A map of the mechanisms ahead
Now that you’ve bought the thesis — the value is yours, so let’s route it back — the rest of the course is a tour of the concrete plumbing that pulls it off. Here’s the map.
- Order-flow auctions & refunds (lesson 2): the direct mechanism. Auction the right to your transaction, keep a sliver, refund you the rest. This is redistribution in its purest, most literal form.
- Intents & solvers (lessons 3–4): instead of signing a transaction (“do exactly this”), you sign an intent (“I want at least this outcome”) and let a competitive market of solvers fight to fill it on the best terms. Competition among solvers is itself a redistribution engine — they bid surplus back to you to win your business.
- Programmable privacy & decentralized sequencing (lesson 5): SUAVE-style neutral infrastructure — the democratize endgame that lets all of the above run without trusting one monopolist auctioneer.
- The tradeoffs (lesson 6): every rebate has a catch — trust assumptions, centralization risk, latency, the question of whether you’re really getting the best price or just a prettier story. We’ll be appropriately suspicious.
But underneath every one of those mechanisms sits the same engine: ordering has value, and that value is what’s being auctioned. Reorder the same set of pending transactions and the total extractable value changes — that’s the whole reason there’s anything to redistribute. Sit with that for a moment.
Transaction ordering
Must run right after Alice
Wins the collateral if it goes first
- Tips captured
- 23 gwei
- Extra MEV captured
- 0 gwei
- Total value captured
- 23 gwei
The same mempool, reordered. Flip between fee-priority, builder-optimal, and FIFO orderings and watch the captured value move — that delta is precisely the MEV every mechanism in this course is fighting over. Redistribution doesn't shrink this number; it changes whose wallet it lands in.
Place each item in the right group.
- A searcher sandwiches your swap and pays the validator a bribe.
- A solver wins your intent by quoting a better-than-market price and passing surplus to you.
- MEV-Boost lets the validator capture your transaction's MEV efficiently — and keep it.
- Your public-mempool swap gets back-run; the builder and validator split the profit.
- Your wallet aggregates millions of orders and negotiates a rebate it pays back to users.
- An order-flow auction refunds 85% of your back-run value to your wallet.
Big picture
- The Redistribution Turn
- The problem
- You create the MEV (your swap is the opportunity)
- Value flows UP: searcher → builder → validator
- You get $0 of value you generated
- Four verbs
- Minimize — hide the order (privacy)
- Capture — PBS/MEV-Boost (validator keeps it)
- Redistribute — refund the user (this course)
- Democratize — neutral layer (SUAVE, lesson 5)
- Order flow is an asset
- Right to execute/back-run has market value
- Sell it, refund the user (loyalty cashback, not skimming)
- User = natural owner
- Creates the opportunity
- Refund = price improvement
- Realigns incentives — less reason to attack
- Wallets/apps aggregate and negotiate
- Mechanisms ahead
- Order-flow auctions (lesson 2)
- Intents & solvers (lessons 3–4)
- Programmable privacy / SUAVE (lesson 5)
- Tradeoffs (lesson 6)
- The problem
Recap: the redistribution turn
Define it: in this course, 'redistribution' of MEV means…
Check your answer to continue.
So the thesis is set: extraction is here to stay, the value was always yours, and the job is to build plumbing that routes it home. The cleanest, most direct way to do that is to literally hold an auction for the right to touch your transaction — and pay you the proceeds. That mechanism has a name, a market, and a surprising amount of subtlety. In lesson 2 we open the hood on order-flow auctions and refunds: how the bidding works, who runs it, what cut they take, and how the rebate actually lands back in your wallet. The tip jar is about to start paying you.