ENDGAME: How we break performance limits with EigenDA

Mega GM // Gmega

In our last article, we explained how MegaETH's breakthrough node specialization unlocks the upper bounds of blockchain performance while keeping node specs low.

That was only one part of the story though.

Behind the 100k TPS / 10 gigagas numbers lies another crucial component that makes our performance possible: Data Availability.

Today, we're pulling back the curtain on what Data Availability is, how it impacts scaling, why Ethereum's blob space falls short, and how EigenDA unlocks MegaETH into performance territories previously deemed impossible.

Let's break it down.

What is Data Availability?

To understand Data Availability (DA), you have to understand why it may be needed and who leverages it.

WHO NEEDS IT?

Blockchains which outsource one or several components of their stack to another chain. For us, that's consensus, and we offload that to Ethereum—the clear-leader for decentralization, liveness and credible neutrality in our industry. This allows MegaETH to create the most-performant execution environment possible because it removes consensus (and it's performance overhead) from the critical path entirely. To enable this, it means maintaining a constant relationship with both Ethereum and EigenDA. MegaETH orders and executes transactions locally while periodically:

Reporting snapshots of asset ownership to Ethereum
Recording all MegaETH transaction to EigenDA

MegaETH's posting relationship to @eigen_da and @ethereum

OKAY, BUT WHY?

Think back to your math teacher demanding "show your work!" It wasn't enough to write down the answer, you needed to demonstrate how you arrived there.

In blockchain, DA is essentially the network "showing its work" to participants. It ensures that all transaction data is publicly available so anyone can verify that state changes have been made correctly.

If users can't independently verify that transactions were executed properly, a blockchain becomes nothing more than a centralized database where operators can easily manipulate records.

After the recent Pectra upgrade, Ethereum's blob target increased from 3 to 6 per block, while the blob limit rose from 6 to 9 per block.

In short, DA is what gives public blockchains their decentralized, trustless properties.

Ethereum's Data Availability Problem

As part of the 2024 Dencun hardfork, Ethereum rollups moved away from using calldata for DA to a cheaper form of data often referred to as "blobs."

Unlike calldata, which is the same type of data used for regular transactions on the L1, blobs do not permanently occupy space on the blockchain and can be pruned by the network after approximately 18 days. This temporary storage model primarily helps to reduce Ethereum’s state bloat, while cost savings emerge from the expansion of a new category of blockspace, which is priced at roughly 1/10ths that of calldata and simultaneously operates a separate fee market.

Despite these efficiency improvements, blob space remains very limited, and Ethereum regulates its demand through a system of blob targets and blob limits. The blob target represents the practical capacity threshold. Once the target is exceeded, the price for additional blob capacity increases exponentially, creating an economic mechanism that prevents network congestion while allowing for surge capacity when needed. As posting blobs beyond the blob target becomes very expensive, rollup operators often adjust their own posting behaviors to stay below the target threshold.

After the recent Pectra upgrade, Ethereum's blob target increased from 3 to 6 per block, while the blob limit rose from 6 to 9 per block.

Ethereum’s DA throughput (following 6 blobs per block target):

Each Ethereum blob holds 128 KB of data.
Ethereum processes 6 blobs every 12 seconds, translating to 64 KB/s of DA throughput (6 blobs x 128KB / 12 seconds).
This limited throughput supports approximately ~100 Megagas/s & ~400 TPS combined across all Rollups, and every L2 must share this constrained resource.

Base alone saturates 25-30% of available blob space with only ~120 TPS & ~35 Megagas/s.

This performance ceiling makes using Ethereum blobs for DA infeasible for a high-performance chain like MegaETH. MegaETH is designed to eventually handle over 10 Gigagas/s and 100K TPS. Our internal tests show that this level of throughput requires a DA layer with a throughput of ~20MB/s.

Visualized:

Even in the most optimistic case for Ethereum scaling with Data Availability Sampling, it is unlikely that the L1 can meet this level of DA throughput in any meaningful timeframe.

PeerDAS is expected to be part of the 2026 Fusaka upgrade and aims to bump the end-state blob target to 48 blobs. However, some napkin math shows that this throughput is still 40x too low to support 100K TPS on MegaETH, and this assumes that no other rollups use Ethereum for DA.

The EigenDA Unlock

MegaETH's unprecedented throughput demands required us to fundamentally rethink data availability, which is why we integrated with EigenDA.

EigenDA is currently live with a DA throughput of 15 MB/s, with plans to increase to 50 MB/s (already live on EigenDA V2 testnet). To put this into perspective, 50 MB/s is approximately 800 times Ethereum's current DA throughput and could support over 250,000 ERC-20 transfers per second.

This capacity is more than sufficient for MegaETH's current requirements and provides ample room for future growth.

EigenDA achieves its breakthrough performance through an architecture that differs fundamentally from Ethereum's approach in two key ways:

Horizontal scaling architecture: While Ethereum's blob capacity is fixed per block, EigenDA scales as more operators join the network. Each additional operator increases the system's total capacity for data processing and storage.
Erasure-coded data sharding: EigenDA divides data into erasure-coded chunks that are strategically distributed across operators. Each chunk is accompanied by a KZG commitment, allowing operators to cryptographically prove to the network that the data they hold is authentic. This setup enables the original data to be reconstructed even if some shards are missing, maximizing throughput while maintaining robust redundancy.

Here's how MegaETH Integrates with EigenDA:

MegaETH's sequencer submits a transaction batch to EigenDA.
The transaction data is erasure-coded and committed using KZG, then chunked and distributed across EigenDA operators.
EigenDA operators validate the KZG commitments using multi-reveal proofs, store the chunks, and send back BLS signatures to the EigenDA disperser.
These signatures are aggregated to form a DA Certificate, which is verified through the EigenDA Verifier contract on Ethereum. Upon successful verification, the MegaETH sequencer sends the DA Certificate to the MegaETH inbox contract on Ethereum.

In parallel, MegaETH posts its State Root, the cryptographic representation of the current state of all account balances on MegaETH, to its bridge contract on Ethereum. By anchoring the State Root on Ethereum, MegaETH benefits from Ethereum's security guarantees.

When fraud-proof Challengers want to verify the validity of MegaETH's state, they fetch blob data from EigenDA, allowing them to confirm that the executed transactions and the resulting State Root match what was posted on Ethereum.

This dual approach—using EigenDA for high-throughput data availability while anchoring state roots to Ethereum for security—gives MegaETH the best of both worlds: Ethereum's strong economic security combined with EigenDA's breakthrough throughput.

All to create the single most-performant blockchain known to our ecosystem, restricted only by hardware and your internet connection.

Summary

The traditional approach of posting all data to Ethereum works well for moderate throughput, but true next-generation performance requires rethinking this model.

As we scale toward 10 Gigagas/second and beyond 100k TPS, our data availability requirements will continue to grow. EigenDA's roadmap aligns with our trajectory, ensuring that we won’t hit DA bottlenecks as we continue to push performance boundaries.

The result is a blockchain that doesn't compromise, delivering real-time performance, with the capacity to support applications that were previously unimaginable.

Build with us.