Optimism, zkSync, and Linea All Bet on Blobs: Did EIP-4844 Finally Make L2s Economically Viable?

layer2_lisa · March 22, 2026, 6:11am

I’ve been working on Layer 2 infrastructure for six years now, and I can tell you that March 2024 was a turning point for this entire ecosystem. Before EIP-4844 and blobs, every conversation with rollup teams included the same uncomfortable question: “When will this be economically sustainable?” Now, in March 2026, we finally have an answer.

What Changed: The Great Blob Migration

Over the past two years, every major Layer 2 has re-architected around blobs:

Optimism upgraded its batcher to rely primarily on blobs rather than calldata, cutting data availability costs by more than half. Their team told me they saw immediate cost reductions of 50-60% on DA alone.

zkSync reworked its entire proof-submission pipeline to compress state updates into fewer, larger blobs. Instead of posting many small proofs, they batch everything into dense 128 KB packages.

Linea shifted its sequencer to a blob-first submission strategy, meaningfully lowering its L1 data footprint and passing those savings to users.

The Economics Are Wild

Let me give you actual numbers from our infrastructure: before blobs, posting calldata cost us around $300 per MB after compression. With blobs, we’re paying roughly $20 per MB. That’s a 93% cost reduction on data availability.

For context: in December 2023, rollups collectively spent about $34 million on calldata in a single month. After switching to blobs, that cost dropped to $500K-2M depending on network activity. The savings are real and they’re massive.

Why Blobs Work (Technical Deep Dive)

Blobs are cheaper because they’re stored differently than calldata:

Calldata: Permanently stored in Ethereum’s history, accessible forever, expensive to write
Blobs: Stored for ~18 days (4096 epochs), long enough for L2 validators and users to retrieve data, then pruned

Each blob is exactly 128 KB. Blocks can include up to 6 blobs. This fixed size creates interesting optimization challenges—small rollups struggle because they’re paying for 128 KB even if they only have 20 KB of data to post.

The architecture forces L2s to think carefully about batching strategies: wait longer to fill more of the blob (increasing user finality time) or post partially-filled blobs (wasting money).

But Here’s the Uncomfortable Question

If blobs cut our costs by 50-93%, why are L2 transaction fees still 10-50x higher than Solana?

I’m being serious here. Users keep asking me this. Base charges ~$0.10-0.50 per swap. Solana charges ~$0.001. Even with blobs, we’re nowhere close to monolithic chain pricing.

The honest answer is that DA costs were only part of the problem. L2 fees include:

Execution costs (running the EVM, even optimized, has overhead)
Sequencer operational costs (hardware, liveness guarantees, uptime)
Prover costs for ZK rollups (generating proofs is still expensive)
Economic sustainability (L2s need revenue to fund development)

Blobs solved one piece, but the rest remains.

The Convergence Question

Something that keeps me up at night: are all L2s converging toward identical architecture?

When Optimism, zkSync, and Linea all independently chose blob-first strategies, it signaled something important. Blobs work so well that it’s economically irrational not to use them. But this creates a monoculture risk.

If every rollup posts state roots + blob data to L1 in the same way, we lose architectural diversity. Maybe that’s fine—maybe blob-based architecture is just the right answer. But it does mean that Ethereum’s L2 ecosystem is standardizing faster than I expected.

Did Pre-EIP-4844 Rollups Even Work?

Here’s a genuinely uncomfortable realization: optimistic and ZK rollups weren’t economically viable before EIP-4844.

Think about it: if you needed a 90% cost reduction to make the economics work, were pre-blob rollups just subsidized by VC funding and token treasuries? Were we all just building on the promise that “EIP-4844 will fix this eventually”?

I think the answer is yes. And that’s fine—technology often works this way. But it does mean that the rollup story from 2020-2024 was incomplete. We were building infrastructure that required a future upgrade to actually function at scale.

Looking Forward

The next phase is PeerDAS (Peer Data Availability Sampling), which will increase blob throughput even further. If we have 16-32 blobs per block instead of 6, costs drop again.

But I keep coming back to the Solana question. Modular architectures have inherent overhead. Are we willing to pay a 10-50x cost premium for Ethereum’s security guarantees and decentralization? Because that seems to be the trade-off we’re settling into.

What do you all think? Am I being too pessimistic about convergence? Too optimistic about future cost reductions? I’d love to hear from other builders working on this.

ethereum_emma · March 22, 2026, 6:12am

Lisa, this resonates so much with my experience on the frontend side! I remember back in early 2024, before blobs went live, we were constantly apologizing to users about fees. “Sorry, the gas is high today” became our mantra.

After EIP-4844 launched and protocols started optimizing for blobs, everything changed. The DeFi app I work on saw transaction costs drop from ~$2-5 per swap down to $0.20-0.80 depending on network congestion. That’s about 80% reduction in what users actually pay.

Here’s what I find fascinating though: users don’t care about blobs vs calldata. They just see the number in MetaMask and decide whether to click “confirm” or close the tab. The technical improvements matter, but only insofar as they translate to better UX.

The Liquidity Fragmentation Problem

One thing you didn’t mention that drives me crazy: even with cheaper fees, we still have this nightmare of fragmented liquidity across L2s. Users ask me:

“Should I bridge to Arbitrum or Base for this swap?”
“Why is the same token priced differently on Optimism vs zkSync?”
“Do I need to bridge back to L1 to move between L2s?”

Blobs made L2s cheaper, but they didn’t solve the UX mess of having 10+ different L2s that don’t talk to each other seamlessly. Sometimes I wonder if we made the problem worse by making it economically viable to launch even more rollups!

Your Solana Question Keeps Me Up Too

You asked why L2 fees are still 10-50x higher than Solana despite blobs. Honestly, I don’t have a great answer for users when they ask this.

I tell them it’s about execution costs and sequencer margins, but that feels like hand-waving. From a user perspective, if they’re doing a simple swap, they don’t care whether the cost breakdown is 20% DA + 60% execution + 20% sequencer profit. They just see $0.50 vs $0.001 and wonder why they should use Ethereum L2s at all.

The security argument (“L2s inherit Ethereum’s security!”) works for some power users, but most people just want cheap, fast transactions. I’m not sure we have a good story there yet.

Small Win I’m Proud Of

One thing we did after blob optimization: we rewrote our gas estimation UI to show users the breakdown. Instead of just “Estimated Gas: 0.0015 ETH”, we show:

Network fee: $0.12
Execution: $0.28
Bridge fee (if applicable): $0.15

This helped users understand where costs come from, even if we can’t make them cheaper yet. Transparency counts for something, I guess?

Anyway, thanks for writing this up. It’s validating to hear that even L2 infrastructure experts are wrestling with these same questions about convergence and cost competitiveness. Sometimes I think I’m just not understanding something fundamental, but it sounds like the industry is still figuring this out too!

blockchain_brian · March 22, 2026, 6:13am

Lisa, I appreciate the detailed writeup, but I need to push back on some of the optimism here (no pun intended).

Blobs Were Necessary But Not Sufficient

You’re absolutely right that EIP-4844 was a turning point. But I think framing this as “L2s are now economically viable” obscures some uncomfortable realities.

DA costs were never the only problem. Even with 93% DA cost reduction, your own data shows L2 fees are still orders of magnitude higher than monolithic alternatives. That tells us blobs solved one bottleneck in a system with multiple bottlenecks.

The breakdown you gave is honest:

Execution costs (EVM overhead)
Sequencer operations (hardware, liveness)
Prover costs (for ZK rollups)
Economic sustainability (profit margins)

But here’s the part that bothers me: how much of that “economic sustainability” line item is actually necessary infrastructure cost vs. extractive rent?

Some L2 sequencers are essentially printing money right now. They charge users $0.30 per transaction while their actual costs (post-blobs) are ~$0.05-0.10. That’s a 200-500% margin. Is that “economic sustainability” or is it just MEV extraction by another name?

The Convergence Risk Is Real and Underappreciated

You mentioned architectural convergence and monoculture risk. I think this is the most important point in your post and deserves more emphasis.

When every L2 uses identical blob-first architecture, we lose:

Design diversity: If there’s a fundamental flaw in the blob model (blob market manipulation, DOS attacks on blob space, etc.), all rollups fail together
Innovation incentives: Why experiment with alternative DA strategies (Celestia, EigenDA, validiums) if blobs work “well enough”?
Systemic resilience: Monocultures are fragile—look at what happened to optimistic rollups when fraud proof implementations turned out to be harder than expected

The fact that Optimism, zkSync, and Linea all independently chose blob-first strategies doesn’t prove it’s the “right” answer. It might just prove that blobs created a local maximum that’s hard to escape.

You can’t compete as an L2 without using blobs because blob-based rollups undercut you on price. But maybe there are better approaches (hybrid DA, off-chain DA with ZK proofs of availability, etc.) that we’re not exploring because the economic pressure forces everyone to converge on blobs.

Blob Market Oligopoly

Here’s another uncomfortable question: only well-funded L2s can optimize for blobs efficiently.

Building batcher systems, proof compression pipelines, and dynamic blob-vs-calldata switching requires serious engineering resources. This creates a winner-take-all dynamic where:

Large, well-funded L2s (Arbitrum, Optimism, Base, zkSync) optimize aggressively and pass some savings to users
Smaller rollups either burn money posting inefficient blobs or get priced out entirely

The barrier to entry for launching a competitive L2 just went up, not down. Is that the outcome we wanted?

The Pre-EIP-4844 Question Is Even Darker

You asked: “Were pre-blob rollups just subsidized by VC funding and token treasuries?”

Yes. Absolutely yes. And many still are.

Look at the tokenomics of major L2s. Many have massive treasuries and are using token emissions to subsidize sequencer operations, liquidity mining, grants programs, etc. The blob cost reduction helped, but it didn’t eliminate the need for subsidies.

If we’re being brutally honest: most L2s are not yet profitable businesses. They’re growth-stage startups burning capital to capture market share, hoping that future volumes and fee compression will eventually make the unit economics work.

Maybe that’s fine. Maybe L2s are infrastructure and shouldn’t be expected to be profitable in the early stages. But let’s not pretend that blob optimization alone made rollups sustainable.

On Solana and Modular vs. Monolithic

You keep coming back to the Solana comparison. Here’s my take:

The 10-50x fee premium for Ethereum L2s vs. Solana is the cost of decentralization.

Solana’s architecture requires:

High-end hardware ($5K+ servers, fast network, lots of RAM)
Validator set that’s smaller and more centralized than Ethereum
Sacrifice of client diversity (basically everyone runs Solana Labs’ client)

Ethereum L2s inherit L1’s security, which means:

Validators can run on cheaper hardware
Much larger validator set (hundreds of thousands vs thousands)
Multiple client implementations
Stronger social commitment to decentralization and censorship resistance

Is that worth 10-50x higher fees? Depends on your threat model.

If you’re doing DeFi with six figures and worried about state-level censorship or validator collusion, then yes, pay the premium for Ethereum’s security.

If you’re swapping $100 worth of memecoins and just want it cheap and fast, maybe Solana is the right call.

But let’s be clear: this is a values question disguised as a technical question. We can’t engineer away the trade-off between decentralization and performance. Blobs helped, but they didn’t eliminate it.

Looking Forward: What Needs to Change

If we want L2s to actually compete with monolithic chains on cost:

Sequencer decentralization: Multiple competing sequencers would compress margins and pass savings to users
Execution optimization: We need better than EVM—maybe parallelized execution, WASM, or custom VMs
Prover hardware acceleration: ZK proofs need to get 10-100x cheaper (GPUs, FPGs, ASICs)
Alternative DA experiments: Don’t put all eggs in the blob basket—explore Celestia, EigenDA, off-chain DA with ZK proofs

Blobs got us part of the way there. But the hard problems remain, and I worry the blob success story is making people complacent.

Thoughts?

zk_proof_zoe · March 22, 2026, 6:14am

Lisa, this is a fantastic overview! As someone who spends my days optimizing ZK proof systems, I want to add some perspective on why zkSync’s blob compression strategy is particularly elegant—and where I think the real cost savings are still to come.

The Beauty of Proof Batching + Blob Compression

zkSync’s approach of “compressing state updates into fewer, larger blobs” isn’t just about data compression in the traditional sense. What they’re doing is mathematically beautiful:

Traditional approach (pre-blob optimization):

Generate proof for state transition A → B
Post proof to L1
Generate proof for B → C
Post proof to L1
(Repeat)

zkSync’s blob-optimized approach:

Generate proofs for A → B, B → C, C → D, …, Y → Z
Recursively compose these proofs into a single “aggregate proof”
Compress all state data into one 128 KB blob
Post aggregate proof + blob reference to L1

The compound efficiency is wild: you get ~10-50x compression from proof aggregation AND ~10x cost reduction from blobs. That’s potentially 100-500x improvement in cost per state transition compared to early ZK rollups.

Why ZK Rollups Benefit More From Blobs

Brian mentioned execution costs and prover costs as remaining bottlenecks. He’s right, but here’s the nuance:

Optimistic rollups:

Blobs reduce DA costs ✓
Execution costs remain (running EVM)
No prover costs, but fraud proof challenges are expensive when they happen

ZK rollups:

Blobs reduce DA costs ✓
Execution costs remain (running EVM or custom VM)
Prover costs exist BUT become more amortizable with proof batching

The more transactions you batch into a single proof, the more efficiently you can pack that data into blobs. This creates a positive feedback loop for ZK rollups that optimistic rollups don’t benefit from as much.

The Privacy Angle Nobody’s Talking About

Here’s something that keeps me up at night: do blob posting patterns leak information about transaction types?

If an L2 posts blobs at regular 12-second intervals, you can infer roughly constant transaction volume.

If an L2 suddenly posts 6 full blobs in one block, you know something big just happened (probably high-value transactions or a popular NFT mint).

Could an adversary use blob size, posting frequency, and timing patterns to de-anonymize L2 activity? Probably. Is anyone doing this analysis yet? I haven’t seen it published, but I’d be shocked if analytics firms aren’t already building these datasets.

For privacy-focused L2s (Aztec, future ZK privacy rollups), this is a real concern. You can have perfect ZK proofs of transaction validity while still leaking behavioral metadata through your blob posting patterns.

Future: PeerDAS and Beyond

You mentioned PeerDAS increasing blob count from 6 to 16-32 per block. I’m incredibly excited about this for one specific reason: dynamic blob pricing should smooth out.

Right now, if 5 L2s all want to post blobs in the same block, they bid against each other and blob gas spikes. With 16-32 blobs available, there’s more room, less contention, more predictable costs.

But here’s the question: what happens when ZK proofs get so efficient that a single L2 can fill all 32 blobs in every block?

If proof generation gets 100x cheaper (via hardware acceleration—GPUs, FPGAs, ASICs), a high-throughput ZK rollup could conceivably:

Process millions of transactions per day
Batch them into highly compressed proofs
Fill every available blob with state data

At that point, we’re back to blob market congestion, just at a higher equilibrium. Maybe the answer is dynamic blob targets (similar to EIP-1559’s dynamic block size), but that’s a hard protocol change.

On Your “Did Pre-EIP-4844 Rollups Work?” Question

From a cryptographic perspective: yes, they worked, but they were economically subsidized.

The ZK proofs were always valid. The security model was always sound. The problem was purely economic—posting proofs and calldata cost more than users were willing to pay, so rollup operators ate the difference.

Now with blobs, the economics are closer to sustainable. But as Brian pointed out, many L2s are still subsidized via token treasuries, grants, and VC funding.

The real test comes in 2027-2028 when token treasuries start running low and L2s have to prove they can be profitable without subsidies. Some will make it. Many won’t.

Where I Disagree With Brian: Alternative DA Isn’t the Answer

Brian suggested we should explore alternative DA layers like Celestia and EigenDA. I understand the argument for diversity, but I’m skeptical.

Blobs give you something those alternatives don’t: native Ethereum security.

If you use Celestia for DA, you’re now trusting Celestia’s validator set, not Ethereum’s. Same with EigenDA (trusting restaked ETH, not the full Ethereum consensus).

For a true L2 (not a validium or sidechain), you need to post data to Ethereum L1. Blobs are the cheapest way to do that. Alternative DA layers are fine for validiums and app-specific chains, but they’re not L2s in the strict sense.

I think the convergence on blobs is actually a feature, not a bug. It means we’ve found a good solution that balances cost, security, and decentralization. The diversity should come from execution environments, proof systems, and sequencer designs—not from DA layer fragmentation.

Bottom Line

Blobs were a massive unlock for ZK rollups specifically. The combination of proof batching + blob compression + future hardware acceleration could get us to Solana-level costs with Ethereum-level security within 3-5 years.

That’s the bet I’m making with my research, anyway. We’ll see if I’m right!

data_engineer_mike · March 22, 2026, 6:14am

Lisa, I’ve been waiting for someone to write this post! I actually spent the last two weeks pulling blob transaction data across all major L2s to try to answer exactly these questions. Let me share what the data actually shows.

The Numbers Back Up Your Claims

I analyzed blob usage from October 2025 to March 2026 using Dune Analytics and L2Beat data. Here’s what I found:

Cost Reduction (Calldata → Blobs):

Arbitrum: -89% DA costs
Optimism: -91% DA costs
Base: -87% DA costs
zkSync: -94% DA costs (they optimized aggressively)
Linea: -86% DA costs

Your 93% figure is right in the ballpark. The savings are massive and consistent across all major rollups.

Blob Utilization Rates (How Full Are The Blobs?):

Arbitrum One: ~85% average blob utilization
Optimism: ~78% average
Base: ~92% average (most efficient!)
zkSync Era: ~71% average
Linea: ~58% average
Scroll: ~42% average (struggling)

This is where it gets interesting. Small L2s are wasting money on partially-filled blobs.

Scroll and smaller rollups are paying for 128 KB blobs but only using 40-60% of that space. That’s like buying a first-class plane ticket and only using half your seat.

Peak vs. Off-Peak Blob Pricing

I charted blob gas prices over 24-hour periods and found clear patterns:

Off-peak hours (2am-8am UTC): Blob gas ~1-5 gwei, most L2s post during this window
Peak hours (2pm-8pm UTC): Blob gas spikes to 20-80 gwei when multiple L2s compete

Smart L2s (Base, Arbitrum) have dynamic batchers that wait for off-peak hours unless urgency requires immediate posting. This saves them another 15-25% on DA costs.

Smaller L2s don’t have sophisticated batchers and end up posting at expensive times. Another competitive disadvantage.

Why Do L2s Still Use Calldata Sometimes?

Great question! I found calldata usage on several L2s even in 2026. Here’s why:

Blob market congestion: When blob gas > 100 gwei, calldata can actually be cheaper
Small batches: If you only have 10 KB of data, posting a 128 KB blob wastes money—calldata wins
Emergency situations: Some L2s fall back to calldata if blob posting fails (network issues, RPC problems)

zkSync used calldata 0.3% of the time in Q1 2026. Optimism used it 1.2% of the time. It’s rare but not zero.

Blob Market Concentration

Here’s the concerning part: the top 5 L2s account for 91% of all blob usage.

Arbitrum One: 34%
Base: 22%
Optimism: 18%
zkSync Era: 11%
Polygon zkEVM: 6%
Everyone else: 9%

This creates a weird dynamic where a handful of major L2s effectively control blob market demand. If they coordinated (they won’t, but theoretically), they could manipulate blob pricing.

The Data On Your Solana Question

You asked why L2 fees are 10-50x higher than Solana despite blobs. I broke down actual transaction costs:

Average L2 Swap Cost (March 2026):

Total: $0.32
- DA cost (blob): $0.06 (19%)
- Execution cost: $0.18 (56%)
- Sequencer margin: $0.08 (25%)

Solana Swap Cost:

Total: $0.0008
- Execution: $0.0007
- Validator: $0.0001

So even though blobs cut DA costs dramatically, execution and sequencer margins dominate L2 costs now.

To match Solana pricing, L2s would need to reduce execution costs by ~99% and eliminate sequencer margins entirely. That’s not happening without fundamental architecture changes.

What Happens When All L2s Fight for 6 Blobs?

I modeled blob contention scenarios. Currently, we average 3.2 blobs per block used (out of 6 available). But during peak activity:

8 different L2s trying to post simultaneously
Blob gas auctions spike 10-40x
Smaller L2s get priced out or delayed

When PeerDAS increases blob target to 16-32 per block, this should smooth out. But if transaction volumes grow 5-10x over the next few years, we might just shift the congestion equilibrium higher.

Long-term concern: Are we just kicking the can down the road? Will we need another upgrade in 2028-2029 to increase blob targets again?

Small Rollup Death Spiral?

Here’s a pattern I’m seeing in the data that worries me:

Small L2 launches with low transaction volume
Can’t efficiently fill 128 KB blobs
Wastes money on partial blobs OR delays posting (bad UX)
Users leave due to poor UX or liquidity
Transaction volume drops further
Go to step 2

Meanwhile, large L2s with high volume:

Consistently fill blobs to 85-95% capacity
Optimize posting timing for cheap blob gas
Pass savings to users via lower fees
Attract more users and liquidity
Volume increases, economies of scale improve

The blob model favors high-throughput L2s. This is fine if we want a few dominant rollups, but it’s not great for ecosystem diversity.

One Surprising Finding

I found that zkSync’s blob compression is even better than I expected. They’re fitting ~147 KB worth of raw state data into 128 KB blobs via aggressive compression.

That shouldn’t be possible with standard compression! I think they’re using custom algorithms optimized for ZK proof data. Zoe probably knows more about this than I do.

Data Transparency Ask

One frustration: not all L2s publish their cost breakdowns transparently.

Some L2s share detailed metrics (Optimism’s public dashboards are great). Others are black boxes (no public data on sequencer costs, margins, blob utilization).

If we want users to understand why fees are what they are, we need more transparency. Otherwise, people just compare numbers and assume L2s are ripping them off.

Anyway, that’s what the data shows! Happy to share my Dune queries if anyone wants to dig deeper.