Execution is the new liquidity. In a modular stack, the execution layer is a commodity, but the right to order transactions is not. This ordering right, or proposer-builder separation (PBS), is the critical control point for capturing MEV and liquidity flow.
the-modular-blockchain-thesis-explained
Blog
Why Your Modular Stack is Leaking Value to Searchers
The modular thesis fragments liquidity. Standard bridge and AMM designs turn cross-rollup flows into a free-for-all, allowing external searchers to capture the majority of value. This is a structural leak in your stack.
introduction
THE VALUE LEAK
The Modular Liquidity Trap
Modular architecture inadvertently outsources your most valuable asset—liquidity—to extractive third-party searchers.
Your rollup is a data availability (DA) wrapper. Without a native block builder, your sequencer defaults to a first-come-first-served queue. This creates a public mempool that professional searchers like Flashbots and bloXroute exploit for arbitrage and front-running.
You leak value to the supply chain. Searchers capture the arbitrage between your DEX pools (e.g., Uniswap, Curve) and external venues like Binance. This is extractable value (EV) that should subsidize your network security or user fees but instead enriches third parties.
Evidence: On Arbitrum and Optimism, over 80% of profitable MEV bundles are built by a handful of professional builders. Your modular chain's liquidity is the feedstock for their profit, creating a persistent value leakage from your ecosystem to theirs.
key-trends
MODULAR STACK VULNERABILITIES
The Three Leaks in Your Plumbing
Your modular architecture's separation of concerns creates predictable inefficiencies that searchers and MEV bots exploit for profit, draining value from users and the protocol.
01
The Execution Layer Black Box
Delegating execution to a generic sequencer (e.g., Espresso, Astria) creates a blind spot. You cannot see or control the order of transactions within a block, ceding the ~$700M annual MEV opportunity to external searchers.
- Leak: Inability to capture backrunning or arbitrage value.
- Consequence: User trades are consistently front-run, resulting in worse prices.
$700M+
Annual MEV Leak
0%
Protocol Capture
02
The Interchain Delay Arbitrage
Settlement and data availability layers (e.g., Celestia, EigenDA) have finality latencies (~2 seconds to ~20 minutes). Searchers exploit this window for cross-chain arbitrage, knowing your bridge or liquidity pool state is stale.
- Leak: Predictable price discrepancies between L2 and L1 DEXs.
- Consequence: Users suffer from slippage and failed transactions, while bots profit.
2s-20m
Exploitable Window
5-15%
Typical Slippage
03
The Shared Sequencer Bottleneck
Relying on a shared sequencer network for decentralized ordering creates a predictable, low-throughput queue. Searchers pay premium fees to jump this queue, normalizing gas auctions and pricing out ordinary users.
- Leak: Transaction ordering becomes a paid privilege, not a fair first-come-first-serve.
- Consequence: User experience degrades; your chain's TPS is gated by auction mechanics, not technical limits.
10-100x
Fee Spikes
-30%
User Tx Success
deep-dive
THE VALUE FLOW
Anatomy of a Leak: From AMM to Bridge
Modular architecture creates predictable, extractable inefficiencies between your AMM and your bridge.
The modular stack leak is a predictable arbitrage opportunity created by latency between execution and settlement layers. Your application's user flow is a searcher's revenue stream.
Intent-based architectures like UniswapX externalize routing complexity, but the winning solver captures the MEV. Your protocol subsidizes their infrastructure by paying for failed bundle gas on Ethereum.
Cross-chain swaps are the ultimate leak. A user's swap on your chain creates a latency arbitrage between your AMM price and the destination chain price via Stargate or LayerZero.
Evidence: Over $1.2B in MEV was extracted from cross-chain arbitrage in 2023, with bridges like Across and protocols like CowSwap building entire businesses on capturing this value.
MODULAR STACK ARCHITECTURE
The Value Leak: A Comparative View
How different execution layer designs capture or leak MEV and transaction ordering value to external searchers.
| Extractable Value Vector | Monolithic L1 (e.g., Ethereum) | Shared Sequencer (e.g., Espresso, Astria) | Sovereign Rollup (e.g., Celestia Rollup) |
|---|---|---|---|
Sequencer Revenue Capture | 0% (Validators/Proposers) | ~80-90% (Shared Sequencer) | 100% (Rollup Operator) |
Proposer-Builder Separation (PBS) Support | |||
Cross-Domain MEV Capture | ❌ (Limited to L1) | ✅ (Via Shared Sequencing) | ❌ (Isolated to Rollup) |
Time-to-Inclusion Latency for User | < 12 seconds | < 2 seconds | ~20 minutes to L1 finality |
Censorship Resistance Guarantee | Economic (PBS Auction) | Economic + Governance | None (Centralized Sequencer) |
Fee Market Complexity | Global (EIP-1559) | Local per Rollup | Local per Rollup |
Value Leak to External Searchers | High (via Builder Market) | Medium (via Auction Design) | Total (if sequencer is outsourced) |
counter-argument
THE VALUE LEAK
The Optimist's Rebuttal (And Why It's Wrong)
Modular design unintentionally creates new profit centers for searchers, extracting value from your protocol and its users.
Searchers capture MEV margins. Your modular stack's separation of execution, settlement, and data availability creates latency and information asymmetry. This gap is the new frontier for generalized searchers like Flashbots and Jito Labs, who profit from cross-domain arbitrage your users cannot access.
Your users pay the tax. Every cross-rollup swap via Across or Stargate includes a hidden cost: the searcher's profit for arranging liquidity and ordering transactions. This is a direct value transfer from your application's economic activity to third-party extractors.
Shared sequencers are not a panacea. Proposals like Astria or Espresso consolidate ordering but centralize a critical function. You trade technical leakage for political risk, outsourcing a core component of user experience and security to an external, profit-driven entity.
Evidence: On Arbitrum and Optimism, over 15% of cross-domain bridge volume is captured by searcher bots for arbitrage, a multi-million dollar annual subsidy paid by applications that built the demand.
takeaways
MODULAR STACK OPTIMIZATION
How to Plug the Leak: A Builder's Checklist
Your modular architecture's seams are where searchers and MEV bots extract billions in value. Here's how to reclaim it.
01
The Problem: Unprotected Inter-Domain Messaging
Standard bridges and generic message layers like LayerZero or Axelar are blind to execution. They broadcast intents, allowing searchers to front-run cross-chain swaps and liquidations.
- Leak: Searchers capture >60% of cross-chain MEV.
- Impact: Poorer UX, higher effective fees for end-users.
>60%
MEV Capture
$2B+
Annual Value
02
The Solution: Enforce Intents at the Protocol Layer
Adopt an intent-centric architecture. Let users declare what they want, not how to do it. Use solvers (like UniswapX or CowSwap) to compete for optimal fulfillment.
- Benefit: MEV is internalized as solver competition, improving price execution.
- Action: Integrate an intent standard or use a shared solver network like Across.
~20%
Better Execution
0 Slippage
Guaranteed
03
The Problem: Transparent Mempool on Your Settlement Layer
Using a public mempool (e.g., default Ethereum) is broadcasting your user's transactions to the entire searcher network. This is the primary source of arbitrage, sandwich, and liquidator bots.
- Leak: >90% of DEX trades on Ethereum are susceptible to sandwich attacks.
- Impact: Users consistently pay 5-50 bps more than the quoted price.
>90%
Attack Surface
5-50 bps
User Loss
04
The Solution: Integrate a Private RPC & Order Flow Auction
Route transactions through a private RPC (e.g., BloXroute, Titan) to a sealed-bid Order Flow Auction (OFA) like Flashbots Protect or Kolibrio. This bundles and commits transactions directly to the block builder.
- Benefit: User transactions are shielded from front-running.
- Benefit: Value from order flow is auctioned and can be shared back with users/applications.
~0ms
Front-run Window
80%+
MEV Rebated
05
The Problem: Naive Sequencer Design
A first-come-first-serve sequencer is a goldmine for latency arbitrage. Searchers with better infrastructure (~1ms advantages) can consistently reorder transactions for profit.
- Leak: Centralizes value to a few high-frequency players.
- Impact: Degrades network fairness and predictability for honest users.
1ms
Advantage Needed
O(1)
Fairness Score
06
The Solution: Implement Time-Boost or Commit-Reveal Sequencing
Adopt sequencer designs that neutralize latency advantages. Time-boost mechanisms (inspired by Aptos) or commit-reveal schemes force searchers to commit to transaction order before revealing content.
- Benefit: Eliminates pure latency races, democratizing access.
- Action: This must be a core design choice for your rollup or appchain, not a bolt-on.
0 Latency
Arbitrage
Decentralized
Access
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall