Order-Flow Auctions

Lesson 1 left you with a thesis and a verb. The thesis: when your swap creates extractable value, you are the natural owner of it — not the searcher who happens to land a transaction behind yours, and not the validator who sells the slot. The verb was redistribute. Nice slogan. But a slogan doesn’t move a single wei back into your wallet.

This lesson turns the verb into a machine. That machine is the order-flow auction (OFA): instead of broadcasting your transaction to the public mempool where anyone can pick the value off it for free, you route it through an auction that sells the right to execute or back-run your transaction in a sealed bid — and then refunds most of the winning bid back to you. The value your order creates stops leaking to strangers and comes home. Mostly.

What an order-flow auction sells

Think of your swap as a house with an oil well in the backyard you didn’t know about. In the public mempool, you list the house and anyone can quietly pump the oil for free the moment you move in. An OFA instead holds a sealed auction for the drilling rights before you close — and hands you the auction proceeds.

Precisely: you route your transaction to the OFA through a special RPC endpoint (or a wallet integration that does it for you) instead of dropping it into the public mempool. Order flow is just the stream of transactions a user — or a wallet aggregating many users — sends; routing it to an OFA is choosing where that stream goes. The OFA exposes the order — or only a hint of it, enough to bid against but not enough to front-run — to a set of searchers. Those searchers bid for the exclusive right to land a transaction in the slot immediately after yours: the back-run slot. Highest bid wins, the winner’s transaction is placed right behind yours, and (most of) the winning bid is refunded to you.

That back-run slot is the same one from the MEV supply chain you already know — the spot where a benign arbitrageur re-balances a pool you just moved, or a liquidator finishes a job your trade made possible. Here’s the ordering it’s fighting over:

So an OFA isn’t selling your tokens or your trade. It’s selling one specific, narrow privilege — who gets to act immediately after you — and giving you the gate receipts.

The refund split, worked out

Now the arithmetic, because “mostly” and “most of” are doing a lot of work and you should be able to compute the actual number.

Define four quantities:

• V — the gross extractable value your order creates in the back-run slot (the arbitrage or liquidation profit available right behind your trade).
• B — the winning bid. Searchers bid up toward V as competition rises, so write B = c · V, where the competition factor c runs from 0 (one lazy bidder) to 1 (a packed, cutthroat auction).
• r — the refund share routed to you (e.g. 0.90).
• The split then falls out:
  • Your refund = r · B
  • Operator fee = (1 − r) · B
  • Searcher profit = V − B (whatever the winner didn’t bid away)

Worked example. Your swap creates $100 of back-run value, so V = $100. The auction is competitive but not perfect, so the winning bid lands at 80% of value: B = 0.80 × $100 = $80. The refund share is r = 0.90.

• Your refund = 0.90 × $80 = $72.
• Operator fee = 0.10 × $80 = $8.
• Searcher profit = $100 − $80 = $20.

Check: $72 + $8 + $20 = $100 = V. The pie is exactly the value your order created; the auction just decides who gets which slice. In the public mempool, you’d have gotten $0 of that $100 — the whole pie went to whoever won the free-for-all. Now crank competition: if c rises to 0.95, B = $95, your refund = 0.90 × $95 = $85.50, and the searcher’s slice shrinks to $5. The harder searchers fight, the more of your own $100 comes back to you.

Competition is the engine

An OFA with one bidder is a vending machine that takes your money and dispenses a thank-you note. The whole mechanism runs on rivalry.

Here’s why. The refund is r · B, and B = c · V. The operator can set r generously (90%, even 100% in public-good designs), but if c is near zero — one searcher, no pressure to bid high — then B is a pittance and r · B is a pittance of a pittance. You can refund 100% of almost nothing and the user still gets almost nothing. With many searchers, c → 1, B → V, and your refund approaches r · V: nearly the full value, scaled only by the operator’s modest cut. Competition, not generosity, is what fills the refund.

This is the same engine from the cost-stack lesson — pointed in a new direction. In plain on-chain MEV, searchers compete in the public auction too, but they bid their profit away to the validator (via priority fees / the MEV-Boost block auction). The pressure is real; it just flows uphill to whoever sells the block space. An OFA takes that exact same competitive pressure and aims it at refunding the user instead. Same physics, different beneficiary. You didn’t reduce how hard searchers fight — you changed who collects the spoils of the fight.

Real systems

This isn’t a thought experiment running on testnet vibes. OFAs route real volume on Ethereum today.

• MEVBlocker — a public-good RPC endpoint. You point your wallet at it, your transactions skip the public mempool, and searchers bid for the back-run slot in a sealed auction. It refunds roughly ~90% of captured back-run value to users and validators, and it’s free to use. Switching to it is a one-time RPC change — no new contract, no new token.
• Flashbots MEV-Share — a programmable-privacy OFA. Instead of exposing your whole order, you publish a configurable hint (which pools you touch, perhaps, but not your exact size or direction), and searchers bid to back-run against the hint. You choose how much to reveal and how the refund splits. It’s the bridge between “refund my back-run value” and “don’t leak me to sandwichers,” and lesson 5 dissects it in detail.
• The general backrun-auction pattern — wallets, aggregators, and RPC providers increasingly run their own version: capture the order flow, auction the back-run slot, rebate users. The mechanism has become a standard piece of wallet plumbing rather than a niche experiment.

What an OFA can’t do

OFAs are genuinely good, which is exactly why it’s worth being precise about their limits — overselling them is how you get burned.

• It needs a trusted-ish operator. Someone runs the auction, sees the order flow, and is supposed to refund you honestly. If they exclude searchers, skim more than they claim, or peek at your flow, you’re trusting them to behave. How much trust, and how to minimize it, is the whole subject of lesson 6.
• It only refunds what searchers will bid for. No extractable value behind your trade → no bid → no refund. A tiny swap in a deep, already-balanced pool may create ~$0 of back-run value; 90% of $0 is $0. The OFA can’t manufacture value that isn’t there.
• There are latency and inclusion tradeoffs. Running an auction takes time, and routing through one operator can mean slightly slower inclusion or dependence on that operator’s connectivity than firing straight into the public mempool.
• It redirects MEV — it doesn’t eliminate it. The arbitrage still happens; the liquidation still happens. The OFA changes who gets paid, not whether extraction occurs. (To actually shrink the value created, you change the execution itself — which is where intents and solvers come in, next lesson.)

Notice the quiet assumption running through this whole lesson: you still wrote the transaction. You picked the pool, the size, the slippage, the route — and the OFA simply refunds the value that your specified execution threw off. That’s redistribution layered on top of an execution you still authored.

The next move is more radical. What if you stop authoring the execution at all — and just say what outcome you want? That’s the world of intents and solvers, where you sign “give me the best price for 10 ETH” and let a competitive market figure out the how. The auction stops bidding for the scraps behind your trade and starts bidding to build the trade itself. Lesson 3.