Data Availability Layers: Celestia and EigenDA in Layer 2 Scaling

1. Introduction

The single largest cost component of an Ethereum rollup is not execution—it is data availability (DA). Every transaction batch posted by an L2 must be made available to anyone who wants to reconstruct state, challenge fraud, or exit without permission. Posting that data as calldata or blobs on Ethereum L1 is secure, but it is also the bottleneck: rollups historically spent 80–95% of their fees just on DA before EIP-4844.

Dedicated Data Availability Layers—Celestia, EigenDA, Avail, and others—decouple data publication from execution and settlement. They offer rollups orders-of-magnitude cheaper byte-storage with cryptoeconomic or cryptographic guarantees that the data was actually published.

This article dissects the two leading DA networks: Celestia, a sovereign DA chain built on Tendermint with data availability sampling (DAS), and EigenDA, a restaking-secured DA service built on EigenLayer. We compare their architecture, security models, throughput, developer ergonomics, and the rollup ecosystems forming around them.

2. The Scaling Challenge

Ethereum L1 finalizes ~15 transactions per second. Optimistic and ZK rollups push effective throughput to thousands of TPS by executing off-chain and posting compressed batches back to L1. But the rollup's security still depends on data availability: if batch data is withheld, validators cannot construct fraud proofs, ZK provers cannot generate proofs against the latest state, and users cannot force-exit.

Before EIP-4844 (March 2024), rollups stored batches as L1 calldata at roughly 16 gas per non-zero byte. A 100 KB batch cost ~1.6M gas, dominating fees. EIP-4844 introduced blobs: ~128 KB chunks priced on a separate fee market, attached to beacon-chain blocks for ~18 days. This collapsed L2 fees by 10–100×, but Ethereum still targets only 3 blobs/block (~0.375 MB/s) with a 6-blob ceiling.

The classic trilemma—decentralization, security, scalability—applies here too. Posting all rollup data on Ethereum maximizes security but caps aggregate L2 throughput at L1's blob bandwidth. Centralized DA committees (DACs) scale arbitrarily but reintroduce trusted parties.

DA layers attempt to break the trilemma with data availability sampling (DAS): light nodes randomly sample a small fraction of an erasure-coded block; with high probability, if enough honest samplers see their pieces, the full block is recoverable. This means security scales with the number of light clients, not validators—an architectural shift Ethereum itself plans to adopt with PeerDAS.

3. Technical Architecture

3.1 Celestia

Celestia is a sovereign, modular DA blockchain built with the Cosmos SDK and CometBFT (Tendermint) consensus. It does not execute smart contracts. Its only job is to order and publish blob data and produce commitments rollups can reference.

Key primitives:

• Reed–Solomon 2D erasure coding. Each block's data is arranged in a k × k matrix, then extended to 2k × 2k with Reed–Solomon parity. Recovering the full block requires only k² of the 4k² shares.
• Namespaced Merkle Trees (NMTs). Each blob is tagged with a namespace ID. Rollups query only their namespace, paying for verification proportional to their own data, not the entire block.
• Data Availability Sampling. Light nodes randomly request shares; after ~16 successful samples, the probability of an unavailable block being accepted falls below 2⁻¹⁶.

A rollup posts a MsgPayForBlobs transaction:

blob := &blob.Blob{
    NamespaceId: namespace.MustNew(0, []byte("myrollup")),
    Data:        batchBytes,
    ShareVersion: 0,
}
resp, err := client.SubmitPayForBlob(ctx, signer, []*blob.Blob{blob}, gasPrice)
// resp.Height + Merkle inclusion proof are posted to L1 settlement contract

Settlement happens elsewhere (Ethereum, a sovereign rollup's own social consensus, etc.). Celestia provides only the DA attestation.

3.2 EigenDA

EigenDA is a restaking-secured DA service that runs as an off-chain network of operators registered through EigenLayer. It is not a blockchain—there is no consensus over an ordered chain of DA blocks. Instead:

1. A disperser (currently operated by EigenLabs) receives a blob from a rollup, erasure-codes it with KZG commitments, and distributes chunks to operators.
2. Each operator signs an attestation (BLS signature) that they received and stored their chunk for an agreed retention period.
3. Aggregated signatures are posted on Ethereum as a DA certificate. The rollup's settlement contract verifies the cert before accepting the batch.

Security is cryptoeconomic: operators restake ETH (or LSTs) on EigenLayer. Misbehavior—failure to serve data on demand—is in scope for slashing once slashing primitives go live. The KZG commitments allow any party to verify chunks against the original blob without downloading everything.

// Simplified rollup integration
function submitBatch(bytes calldata batch, IEigenDA.Cert calldata cert) external {
    require(eigenDA.verifyCertificate(cert, keccak256(batch)));
    batches.push(BatchHeader({daHash: cert.dataHash, ...}));
}

3.3 Trust Model Differences

Property	Celestia	EigenDA
Consensus	Tendermint BFT (≥2/3 honest)	None (off-chain attestation)
DA proof	DAS over erasure-coded blocks	BLS signatures + KZG commitments
Fault detection	Fraud proofs for incorrect coding	Custody proofs (planned)
Light-client security	Yes, via DAS	No native light client
Inflationary token	TIA (staking)	Restaked ETH

Celestia's security is anyone-can-sample; trust scales with honest light clients. EigenDA's security is quorum-of-restakers; trust scales with stake at risk.

4. Performance Metrics

Benchmarks shift constantly; the numbers below reflect production parameters as of early 2026.

Metric	Celestia	EigenDA	Ethereum blobs
Throughput (current)	~8 MB/s target, ~2 MB/block sustained	~15 MB/s achieved, 1 GB/s claimed ceiling	~0.375 MB/s target
Block time	6 s (moving toward 1 s with Lazy Bridge)	N/A (request-based)	12 s
Finality	~6 s (single slot, BFT)	Ethereum confirmation of cert (~13 min econ. finality)	~13 min
Cost per MB	~$0.01–0.05	~$0.001–0.01	~$0.05–0.50 (variable)
Cost per TX (rollup)	<$0.0001	<$0.0001	$0.001–0.01

A few caveats:

• Celestia's TIA price drives absolute fees; throughput is hard-capped per block, soft-capped by demand.
• EigenDA pricing is set off-chain by the disperser; rollups pay in ETH and post-paid fees vary by tier.
• Both are cheaper but not faster-finalizing than Ethereum blobs from a settlement perspective: a rollup using external DA still inherits its settlement layer's finality.

For comparison, Arbitrum Nova's anytrust DAC publishes ~0.5 MB/s with a 2-of-N trust assumption; Avail offers DAS comparable to Celestia with ~1 MB/s current capacity.

5. Ecosystem & Adoption

Celestia went mainnet in October 2023. The ecosystem grew through the Cosmos and OP Stack worlds:

• Sovereign rollups: Dymension RollApps, Manta Pacific (later migrated parts), Movement.
• OP Stack with Celestia DA: plug-in via op-celestia adapter; used by several appchains.
• Arbitrum Orbit / AnyTrust Celestia integration.
• Public dashboards report >10 PB of cumulative blob data and 50+ rollups posting at least daily.

EigenDA went mainnet in April 2024 and quickly attracted high-throughput rollups:

• Mantle Network migrated to EigenDA, citing >10× cost reduction.
• Celo's L2 transition uses EigenDA.
• Polymer, AltLayer, Arbitrum Orbit chains, Movement, and several gaming chains.

TVL is hard to attribute cleanly because DA is a sub-component. Mantle alone holds >$200M, and aggregate TVL across EigenDA-secured rollups exceeds $700M as of early 2026. Celestia-secured rollups aggregate is smaller in raw TVL (~$200M+) but broader in count and developer experimentation.

Developer activity, by GitHub commits and SDK downloads, favors Celestia for sovereign and Cosmos-native projects, EigenDA for Ethereum-aligned high-throughput rollups.

6. Developer Experience

6.1 Celestia

Integrations are mature for Rollkit, OP Stack, Arbitrum Orbit (AnyTrust Celestia), and Cosmos SDK sovereign rollups. The canonical client is celestia-node, run in light or bridge mode:

celestia light init --p2p.network mocha
celestia light start --core.ip rpc-mocha.pops.one

A rollup sequencer submits blobs via JSON-RPC:

const resp = await client.blob.Submit([{
  namespace: "0x000000000000000000000000000000000000004d79526f6c6c7570",
  data: hexlify(batch),
  share_version: 0
}], 0.002); // gas price in TIA

Documentation at docs.celestia.org is solid. Local devnets via celestia-app Docker images take ~10 minutes to bring up. EVM compatibility is delegated to whatever execution layer the rollup chooses—Celestia itself imposes none.

6.2 EigenDA

EigenDA exposes a gRPC API through the disperser. Integration is well-trodden for OP Stack and Arbitrum Orbit:

client, _ := disperser.NewDisperserClient(addr, opts)
reply, _ := client.DisperseBlob(ctx, &disperser.DisperseBlobRequest{
    Data: batch,
    CustomQuorums: []uint32{0, 1},
})
// poll GetBlobStatus until CONFIRMED, then submit cert on L1

The eigenda-proxy sidecar (used by op-batcher) abstracts this for rollup operators—drop-in replacement for the Ethereum DA backend. Documentation is engineering-focused; recent improvements include fallback proxies, Rust client crates, and Holesky testnet tooling. EVM compatibility, again, depends on the rollup; EigenDA is execution-agnostic.

Migration from L1 DA: for OP Stack, swap the DataAvailabilityChallenge configuration to point at the eigenda-proxy or celestia-da adapter, regenerate the rollup config, and redeploy the batcher. State doesn't need re-indexing; only forward batches go to the new DA.

7. Trade-offs & Limitations

Celestia. Sovereign by design—no canonical settlement on Ethereum means rollups using Celestia for DA must build their own bridge, often with optimistic or ZK proofs over a separate light client. The "ProtoDanksharding-equivalent but cheaper" pitch comes with the caveat that Ethereum-aligned rollups inherit a secondary trust assumption: 2/3 of TIA validators. A successful attack on Celestia consensus could halt or censor DA, though DAS-based fraud proofs limit data forgery.

EigenDA. Operators are a permissioned set onboarded through EigenLayer. Restaked ETH provides cryptoeconomic security, but slashing for DA misbehavior is still being rolled out as of 2026; until then, security leans heavily on social and reputational pressure. The disperser is currently centralized—a liveness chokepoint, though not a safety one (rollups can verify certs independently).

Both. Withdrawal times for rollups using external DA inherit their settlement layer's challenge period (7 days for optimistic, ~hours for ZK). Fragmentation is real: an OP Stack chain on EigenDA cannot trivially exchange messages with a Celestia-DA Orbit chain without a third-party bridge.

Light clients. Celestia ships native light clients with DAS; EigenDA does not (yet). For trust-minimized end-user verification, Celestia is currently ahead.

8. Competitive Landscape

The DA market in 2026 has four main players:

• Ethereum blobs (EIP-4844, future PeerDAS). Maximally trust-minimized; throughput-limited until full Danksharding (~2027+).
• Celestia. First-mover on modular DA, native DAS, sovereign-friendly. Strong in Cosmos.
• EigenDA. Highest-throughput target, ETH-denominated security, native to the Ethereum stack.
• Avail. Polkadot-derived, KZG + DAS, third in adoption.

Celestia's edge is decentralized DAS today and a wide rollup framework support. EigenDA's edge is raw bandwidth and alignment with restaked ETH security. Avail is technically competitive but lags in deployments. Near DA serves NEAR-aligned rollups but is niche.

For an Ethereum-aligned rollup that wants the cheapest non-Ethereum DA without leaving the ETH security perimeter, EigenDA is the default. For sovereign or Cosmos appchains, Celestia is. For maximum trust minimization regardless of cost, Ethereum blobs remain unmatched.

9. Roadmap & Future

Celestia. The "Lazy Bridge" upgrade targets ~1-second block times and ZK light-client bridges to Ethereum. Throughput is being scaled toward 8 MB/s and beyond via larger square sizes. Native rollup-friendly fee abstraction (paying in ETH, not TIA) is on the roadmap.

EigenDA. Decentralized dispersers, on-chain slashing for DA faults, and a native light-client protocol are in progress. Throughput targets approach 1 GB/s in the longer term as restaker counts grow.

Industry. Ethereum's PeerDAS (~2026) and full Danksharding will pressure both networks by raising L1 DA capacity 10–100×. The likely outcome is a layered market: Ethereum blobs for highest-security rollups, EigenDA / Celestia for cost-sensitive high-throughput chains, with frictionless backend switching becoming standard.

10. Conclusion

Data availability layers solve a concrete, measurable problem: posting rollup batches cheaply without surrendering verifiability. Celestia and EigenDA take different routes—Tendermint BFT with DAS versus restaking with KZG attestations—and both deliver order-of-magnitude cost reductions over L1 DA today.

Choose Celestia if you are building a sovereign rollup, value native DAS light clients, or live in the Cosmos ecosystem. Choose EigenDA if you are an Ethereum-aligned high-throughput rollup and prefer ETH-denominated security with execution-layer-agnostic tooling. Choose Ethereum blobs if your security budget tolerates higher per-byte costs in exchange for the strongest available trust model. The right answer depends on your application's economic profile, settlement layer, and how aggressively you need to scale—all three options are now production-grade.

---

Disclaimer: This article was written with AI assistance and edited by the author. It is for informational purposes only and does not constitute financial, investment, or trading advice. Always conduct your own research and consult with qualified professionals before making any investment decisions. Cryptocurrency investments carry significant risk and may result in loss of capital.

Published via NeuralKalym - Automated crypto content system