Ethereum PeerDAS Explained: Data Availability Sampling
Ethereum PeerDAS is the network protocol that lets nodes check whether rollup data is available without downloading every blob in full. It is most relevant to Ethereum node operators, Layer 2 engineers, and developers who need to understand how blob capacity can grow without making every node’s bandwidth grow at the same rate. PeerDAS combines erasure coding, cryptographic proofs, peer-to-peer column distribution, and randomized sampling; it does not make blob data permanent or eliminate the need for healthy, well-connected nodes.
What Is Ethereum PeerDAS?
PeerDAS means Peer Data Availability Sampling. It is Ethereum’s implementation of data availability sampling (DAS) for blob data, specified by EIP-7594. Rather than require each node to download and retain every blob, PeerDAS expands blob data with erasure coding, divides the expanded data into columns, and distributes custody of those columns across the peer-to-peer network.
Each node keeps a deterministic subset of columns and requests random samples from peers. If the samples arrive and their proofs check out, the node gains probabilistic evidence that the block’s data is available. The Ethereum PeerDAS documentation describes the design as part of Fusaka, while the Fusaka roadmap explains why this matters to rollups that publish batches in blobs.
The important distinction is between checking availability and downloading a complete copy. A node can perform the former with a small fraction of the data. A node that needs to reconstruct or archive all blob data still needs enough columns or another data source to do so.
The Problem PeerDAS Solves
Blobs give rollups a purpose-built way to publish transaction data to Ethereum. Before PeerDAS, however, every participating Ethereum node had to receive all the blobs in a block to check their availability. Increasing blob capacity therefore increased bandwidth and temporary storage demands on each node. If the cost rose too far, running a node independently could become harder, concentrating participation in better-resourced data centers.
PeerDAS changes how the network distributes the work. Erasure coding creates redundant data so that a complete blob can be reconstructed from a sufficient portion of its encoded representation. Nodes then hold different subsets instead of all holding the same complete set. Sampling checks whether the network can supply the pieces without asking every node to download them all.
This design helps decouple network-wide data throughput from per-node data requirements. It does not make total network traffic disappear: peers still transmit the columns, and operators still need bandwidth to receive, verify, and serve their assigned data. The goal is to increase capacity more sustainably while keeping ordinary node requirements within practical limits.
How PeerDAS Works
The protocol combines a coding layer, a distribution layer, and an availability-checking layer:
- A blob is committed. A blob transaction includes a commitment to its data. The commitment gives the network a compact reference against which data and proofs can be checked.
- The data is extended. PeerDAS applies erasure coding to create redundant cells. In broad terms, the original data is treated as evaluations of a polynomial, and additional evaluations are added so missing pieces can be recovered.
- Cells are arranged into columns. A column groups cells at a particular index across the extended blob data. Columns are associated with gossip subnets, which provide the network paths for distributing them.
- Nodes custody assigned columns. A node’s identity determines a set of column subnets for which it is responsible. It subscribes to those subnets and stores the columns it receives. Validator participation has additional custody requirements beyond the baseline responsibilities of a regular node.
- Nodes sample peers. For a block, a node requests randomly selected columns from peers that advertise custody of them. The returned cells are checked against the blob’s cryptographic commitment, so a peer cannot make arbitrary data appear valid.
- The node records an availability result. Successful samples provide probabilistic assurance that the data was published. If enough columns are collected, the data can also be reconstructed. EIP-7594 describes reconstruction from at least half of the columns.
In the EIP’s current parameter rationale, a default node downloads roughly one eighth of the total blob data rather than the whole set. That is a protocol-level design point, not a promise that every operator’s actual traffic is exactly one eighth: a node may custody more, validators have extra duties, and real usage varies with peers, retries, and network conditions.
| Mechanism | What it contributes | What it does not guarantee by itself |
|---|---|---|
| Erasure coding | Adds redundancy so missing encoded data can be recovered | That any particular peer is online or honest |
| KZG commitments and cell proofs | Let a node verify sampled cells against committed blob data | That the node has downloaded every cell |
| Column subnets and custody | Distribute data responsibility across nodes | Equal bandwidth or storage use for every operator |
| Random peer sampling | Makes withholding data harder to hide from the network | Permanent storage or deterministic proof from one sample |
| Reconstruction | Recovers the original data when enough columns are available | Availability after the blob retention window ends |
Ethereum’s data availability documentation explains the broader reason for sampling: a participant needs confidence that data required to verify a block exists, even when it does not download all of that data itself.
Components and Key Concepts
Extended blobs, cells, and columns
An extended blob contains the original data plus redundant coded data. Cells are the units that can be individually authenticated with cell proofs. Columns group cells by index across the extended blob set, which lets the network distribute coherent slices of data over dedicated subnets. The distinction matters: a node sampling columns does not simply pick a few arbitrary byte ranges from an unstructured file.
Custody and peer discovery
Custody is the responsibility to retain and serve assigned columns. It is different from sampling: a node can be assigned data to serve while also requesting other data to check availability. Peer discovery helps nodes locate peers that claim custody of particular column groups. The protocol’s security and liveness therefore depend on both valid cryptographic checks and a sufficiently diverse, reachable peer set.
Availability is probabilistic
An individual node cannot infer that all data is available merely because one peer returned one valid sample. The assurance comes from randomized requests, erasure coding, sufficient sampling across the network, and the protocol’s assumptions about participation and connectivity. A malicious producer may try to reveal only enough data to satisfy some requests while withholding the rest. Sampling is designed to make that strategy increasingly difficult to sustain without detection; it is not an absolute guarantee independent of the network.
Real-World Uses and Trade-Offs
PeerDAS primarily supports Ethereum rollups that publish batch data in blobs. By reducing how much each node must download for an availability check, it gives the protocol room to raise blob throughput without requiring every node to scale its bandwidth in lockstep. That can support more rollup data and, when capacity and demand allow, lower data-publication costs.
For node operators, the change shifts attention toward client support, network quality, assigned custody, and the ability to keep up with column traffic. For rollup teams, PeerDAS is part of Ethereum’s data availability path; it does not replace the rollup’s own requirements to publish correctly, monitor inclusion, and preserve data needed beyond the protocol’s retention period.
Capacity increases are still managed carefully. PeerDAS supplies a distribution and sampling design, but blob limits and network parameters can change through coordinated protocol upgrades and Blob Parameter Only (BPO) forks. The Ethereum Foundation’s blob-scaling update describes this gradual approach. Actual throughput depends on configured limits and observed network performance, not on the theoretical maximum alone.
Getting Started: Checking a Beacon Node
There is no standalone command that turns PeerDAS on. Operators need a consensus client release that supports the active Ethereum fork, a correctly configured network and fork schedule, and suitable resources for the node’s custody and sampling duties. Start by checking that the local Beacon API is reachable:
export BEACON_API_URL="http://127.0.0.1:5052"
curl --fail --silent --show-error \
"$BEACON_API_URL/eth/v1/node/version" |
jq -r '.data.version'
curl --fail --silent --show-error \
"$BEACON_API_URL/eth/v1/beacon/headers/head" |
jq -r '"head slot: \(.data.header.message.slot), canonical: \(.data.canonical)"'
These requests use standard endpoints in the Ethereum Beacon API specification. They confirm that the local API responds and report a client version and chain head; they do not prove that PeerDAS sampling is healthy. For that, use the client version’s documentation and metrics or logs to confirm the active fork, column subnet subscriptions, custody assignments, sample-request results, and missed or delayed column traffic. Compare observations across more than one peer or client where possible.
If a node falls behind, separate a general consensus sync problem from column-specific problems. Check peer count and connectivity first, then client logs for failed column requests or proof verification, and finally CPU, disk, and network saturation. Do not respond to missing historical blob data by assuming PeerDAS will retrieve it indefinitely; operators that need old blobs must retain them or use an archive provider.
Common Misconceptions
“A node samples, so it never needs blob data.”
Sampling avoids downloading all data just to check availability. Nodes still receive and custody assigned columns, and applications or operators that reconstruct full blobs need enough data or another source. Sampling does not remove all network and storage costs.
“A valid sample proves every byte is available.”
A valid cell proof confirms that the sampled cell matches the commitment. Availability assurance is probabilistic and comes from the coding and sampling protocol across many nodes. One successful request cannot establish that every peer has all data or that no coordinated withholding attack is possible.
“PeerDAS is permanent blob storage.”
No. PeerDAS changes how blob data is distributed and checked while it is available under the protocol. It does not turn blobs into permanent Ethereum state. Rollups, indexers, and auditors that need long-term data must maintain their own retention strategy.
Related Articles
- Data Availability Sampling and Blob Propagation covers the wider data-availability problem and blob relay operations.
- Proto-Danksharding and EIP-4844 Explained explains the blob transactions and commitments that PeerDAS builds on.
- Blobspace Economics: How Ethereum Prices Rollup Data covers blob capacity, fees, and rollup publication costs.
- Celestia: Modular Blockchain and Data Availability provides a comparison point for data availability sampling in a separate network architecture.
Changelog
- Initial publication: explains PeerDAS’s column distribution, sampling, custody, reconstruction, and node-operator checks.

