What is PeerDAS? Ethereum's data availability sampling, from EIP-4844 blobs to Fusaka

Covalent TeamUpdated 15 min read

PeerDAS (EIP-7594) lets Ethereum nodes check blob data by sampling columns, not downloading every blob. How it builds on EIP-4844 and what Fusaka changed.

PeerDAS (Peer Data Availability Sampling, EIP-7594) is how Ethereum nodes check that rollup data was published without each node downloading all of it. Blob data is erasure-coded into 128 columns, each node stores and samples a few columns from its peers, and because any half of the columns can rebuild the whole, a node that gets its samples can be confident the data is available. PeerDAS went live on Ethereum mainnet with the Fusaka upgrade on 3 December 2025.

It is the second step of a story that started with proto-danksharding (EIP-4844), which added blobs in March 2024. This guide covers both: what blobs are and why they cut rollup fees, why every node downloading every blob became the bottleneck, how PeerDAS's erasure coding, KZG cell proofs and custody work, what changed for nodes and rollups, the blob-parameter-only forks that raise capacity after Fusaka, and how Ethereum's approach compares with Celestia, Avail and EigenDA.

EIP-4844 and blobs: the starting point

Rollups execute transactions off Ethereum but must publish their transaction data on it, so anyone can check their state or rebuild it. Before 2024 that data went into ordinary transaction calldata, which is stored by every node forever and priced like any other execution gas. Data was most of a rollup's cost.

EIP-4844, known as proto-danksharding (after researchers Dankrad Feist, whose danksharding design it prepares for, and Protolambda), gave rollups a cheaper place to put it. It shipped in the Dencun upgrade on 13 March 2024. It added:

  • Blobs. A blob is a fixed-size chunk of 4,096 field elements of 32 bytes each: 131,072 bytes, or 128 KiB. Each element has to be a number below the BLS12-381 field modulus, so encoders such as viem pack 31 bytes of payload into each 32-byte element. The EVM can't read a blob's contents.
  • A new transaction type. A blob transaction is type 0x03. On top of the usual EIP-1559 fields it has max_fee_per_blob_gas and blob_versioned_hashes, one hash per blob it carries, and it must have a to address (a blob transaction can't deploy a contract).
  • KZG commitments and versioned hashes. Each blob has a 48-byte KZG polynomial commitment, a short fingerprint that can later prove what any point of the blob is. The transaction itself carries only the versioned hash: the byte 0x01 followed by the last 31 bytes of the SHA-256 of the commitment. Contracts can read these hashes (the BLOBHASH opcode) and verify proofs about the blob with the point evaluation precompile, which is how ZK rollups tie their proofs to the data.
  • A separate fee market. Each blob costs 131,072 (217) units of blob gas. The blob base fee adjusts like EIP-1559's base fee, but against its own target: it rises when blocks carry more blobs than the target and falls when they carry fewer. Blob fees are burned. At Dencun the target was 3 blobs per block and the maximum 6; the Pectra upgrade (May 2025, EIP-7691) raised them to 6 and 9.

A blob's lifecycle

  1. A rollup's batcher builds a type-3 transaction and computes each blob's KZG commitment and proof.
  2. It is gossiped as a wrapper: the transaction plus the blobs, commitments and proofs. Execution clients check that each commitment hashes to its versioned hash and that the proofs verify.
  3. When the transaction is included, the block holds only the transaction with its versioned hashes. The blobs travel next to the block in the consensus layer as blob sidecars.
  4. Consensus nodes keep blobs for at least 4,096 epochs, about 18 days, then prune them. That is long enough for anyone who needs the data (fraud provers, indexers, rollup nodes syncing) to fetch it. The commitment and versioned hash stay on chain forever.

Blockspace vs blobspace

Blockspace (calldata) Blobspace
Readable by the EVM Yes No, only its versioned hash
Stored Forever, by every full node About 18 days, by consensus nodes
Priced in Execution gas, EIP-1559 base fee Blob gas, its own base fee and target
Used for Contract calls and state changes Rollup batch data
Effect on other users Competes with every other transaction Separate market: busy DeFi blocks don't price it up

Because blob data is temporary, unreadable by contracts and priced in its own market, it can be much cheaper than calldata, and L2 fees dropped sharply after Dencun as rollups moved their data to blobs. For how the two gas markets fit together in a fee, see what is gwei.

Why Ethereum needed PeerDAS

EIP-4844 kept one rule of the old design: every consensus node downloaded every blob in full to attest that a block's data was available. Bandwidth for blobs therefore grew in a straight line with blob count, and the network could only raise the blob target as far as the slowest home staker's connection allowed.

Data availability sampling (DAS) breaks that link. If data is erasure-coded so that any half of it is enough to rebuild all of it, a block producer who wants to hide even one byte has to withhold more than half of the extended data. A node that downloads a few random pieces and gets all of them back can then be confident the rest is available, without downloading it. "Danksharding" was the long-term design for this; PeerDAS is the first version Ethereum shipped, built on its existing peer-to-peer gossip network rather than a new one, which is where "Peer" comes from.

How PeerDAS works

Erasure coding: from blobs to 128 columns

PeerDAS treats a blob's 4,096 field elements as evaluations of a polynomial and uses Reed-Solomon erasure coding to extend it to 8,192 evaluations, twice the size. The extended blob is split into 128 cells of 64 field elements (2,048 bytes) each.

Put all the blobs in a block on top of each other and you get a matrix: one row per blob, 128 columns. Column i is cell i of every blob in the block. Columns are what the network moves around: each travels as a DataColumnSidecar with the block's KZG commitments and a proof that those commitments are in the block. Because the extension doubles the data, any 64 of the 128 columns are enough to rebuild every blob. This is one-dimensional coding (each blob is extended on its own); the full danksharding design envisages a two-dimensional scheme later.

KZG cell proofs

A plain hash can only be checked against the whole data, which is no use when you only download a piece. EIP-4844's KZG commitment can be opened at any point, so PeerDAS attaches a KZG proof to every cell. A node that receives a column checks each cell against that blob's commitment, which it already has from the block. A peer can't hand it a fake cell that passes.

This changed what blob senders do. Since Fusaka, the blob transaction wrapper is version 1: instead of one proof per blob, the sender computes the cell proofs for every cell of the extended blob, 128 per blob, and sends them with the blobs. Fusaka also limits a transaction to six blobs.

Custody groups, subnets and sampling

Columns are spread over 128 custody groups and published on 128 gossip subnets (data_column_sidecar_{subnet_id}), one column per group on mainnet. Which groups a node takes is derived from its node ID by hashing, so any peer can work out which columns a node should hold without asking a coordinator.

  • Custody. Every full node stores and serves at least 4 custody groups. A node with validators attached custodies 8 groups at minimum, plus one group per 32 ETH of attached effective balance, up to all 128.
  • Sampling. Every slot, a node downloads at least 8 groups' columns (its custody groups are a subset of these). If it gets all of them, sampling succeeds. Eight of 128 columns of data that was doubled by the extension is about one eighth of the blob data a node downloaded before PeerDAS.
  • Supernodes. A node that custodies all 128 groups is a supernode. Nodes with 4,096 ETH or more of validators attached are supernodes by rule, and anyone can run one voluntarily.

Reconstruction

A node that collects at least half of the columns should rebuild the full matrix and republish the columns it was missing to their subnets. Supernodes do this all the time, which is what keeps every column available even when some peers go offline. Columns are served for the same 4,096 epochs as blobs were, so the roughly 18-day window for fetching rollup data stays.

See it in code: which columns does a node custody?

This TypeScript implements the spec's custody functions (get_custody_groups, compute_columns_for_custody_group and the validator custody rule from the Fulu consensus specs) with no dependencies:

import { createHash } from "node:crypto"; // Fulu (PeerDAS) constants from the consensus specs.const NUMBER_OF_COLUMNS = 128;const NUMBER_OF_CUSTODY_GROUPS = 128;const SAMPLES_PER_SLOT = 8; // columns every node fetches per slot, at minimumconst CUSTODY_REQUIREMENT = 4; // groups any full node stores and servesconst VALIDATOR_CUSTODY_REQUIREMENT = 8; // a node with validators attachedconst BALANCE_PER_ADDITIONAL_CUSTODY_GROUP = 32; // ETH of effective balance per extra groupconst MAX_UINT256 = (1n << 256n) - 1n; // uint256 -> 32 bytes, little-endian (the spec's uint_to_bytes).const toBytes32LE = (n: bigint) => {    const out = Buffer.alloc(32);    for (let i = 0; i < 32; i++) out[i] = Number((n >> BigInt(8 * i)) & 0xffn);    return out;}; // get_custody_groups: hash the node ID, then ID + 1, ... until enough distinct groups.function getCustodyGroups(nodeId: bigint, count: number): number[] {    if (count === NUMBER_OF_CUSTODY_GROUPS) return [...Array(count).keys()];    const groups = new Set<number>();    let id = nodeId;    while (groups.size < count) {        const digest = createHash("sha256").update(toBytes32LE(id)).digest();        groups.add(Number(digest.readBigUInt64LE(0) % BigInt(NUMBER_OF_CUSTODY_GROUPS)));        id = id === MAX_UINT256 ? 0n : id + 1n;    }    return [...groups].sort((a, b) => a - b);} // compute_columns_for_custody_group: with 128 groups and 128 columns, group g holds column g.function columnsForGroup(group: number): number[] {    const perGroup = NUMBER_OF_COLUMNS / NUMBER_OF_CUSTODY_GROUPS;    return Array.from({ length: perGroup }, (_, i) => NUMBER_OF_CUSTODY_GROUPS * i + group);} // get_validators_custody_requirement: 1 group per 32 ETH attached, at least 8, at most all 128.function validatorCustody(totalEffectiveBalanceEth: number): number {    const count = Math.floor(totalEffectiveBalanceEth / BALANCE_PER_ADDITIONAL_CUSTODY_GROUP);    return Math.min(Math.max(count, VALIDATOR_CUSTODY_REQUIREMENT), NUMBER_OF_CUSTODY_GROUPS);} // A node's discv5 node ID is a 256-bit number; any value works for the demo.const nodeId = 0x1234n;const custody = getCustodyGroups(nodeId, CUSTODY_REQUIREMENT);// Each slot a node fetches max(SAMPLES_PER_SLOT, custody count) groups; its custody groups are a subset.const sampled = getCustodyGroups(nodeId, Math.max(SAMPLES_PER_SLOT, CUSTODY_REQUIREMENT));console.log("custodied columns:", custody.flatMap(columnsForGroup));console.log("sampled columns:", sampled.flatMap(columnsForGroup)); for (const eth of [32, 320, 1024, 4096]) {    console.log(`${eth} ETH attached -> custody ${validatorCustody(eth)} of ${NUMBER_OF_CUSTODY_GROUPS} groups`);}

Run with npx tsx custody.ts. For node ID 0x1234 it prints (Node wraps the longer array over several lines; it is shown on one here):

custodied columns: [ 14, 28, 103, 107 ]sampled columns: [ 14, 26, 28, 85, 103, 105, 107, 109 ]32 ETH attached -> custody 8 of 128 groups320 ETH attached -> custody 10 of 128 groups1024 ETH attached -> custody 32 of 128 groups4096 ETH attached -> custody 128 of 128 groups

The custodied columns are a subset of the sampled ones, and 4,096 ETH is exactly the point where a node must custody everything and becomes a supernode.

What Fusaka changed for nodes and rollups

Fusaka is two upgrades activated together: Fulu on the consensus layer and Osaka on the execution layer. It activated at epoch 411392 on 3 December 2025. PeerDAS is its headline change; the others that touch blobs are:

  • Node operators. Consensus clients now custody and sample columns instead of downloading every blob. A node without validators stores 4 columns; staking nodes store more in proportion to their stake. Clients handle this automatically.
  • Rollups and anyone sending blobs. Blob transactions need the version 1 wrapper with cell proofs and can carry at most six blobs. Libraries and batchers that build blob transactions had to update their KZG code.
  • Blob fees. EIP-7918 gives the blob base fee a floor tied to the execution base fee, so when execution gas is expensive the blob fee can't drop to almost nothing while blobs still cost nodes real work.
  • Reading blob data. Nothing changes for the transaction itself: it still carries blob_versioned_hashes, blobs are still pruned after about 18 days, and the block header still has blobGasUsed and excessBlobGas. Code that reads blob activity from blocks and transactions works as before.

The rest of Fusaka (a per-transaction gas cap, a secp256r1 precompile, the CLZ opcode and others) is listed on ethereum.org's Fusaka page.

BPO forks: raising blob capacity after Fusaka

PeerDAS makes room for more blobs; Blob Parameter Only (BPO) forks (EIP-7892) are how Ethereum uses it. A BPO fork changes only three numbers: the blob target, the blob maximum per block and the base fee update fraction. The schedule is shipped in client releases ahead of time, so capacity can rise in steps without a full hard fork for each one.

Upgrade Date Blob target / max per block
Dencun 13 March 2024 3 / 6
Pectra 7 May 2025 6 / 9
Fusaka 3 December 2025 6 / 9
BPO1 9 December 2025 10 / 15
BPO2 7 January 2026 14 / 21

The BPO1 and BPO2 values are the schedule announced on the Ethereum Foundation blog for mainnet; later steps are announced the same way. Raising capacity in small steps lets client teams watch bandwidth and propagation at each level before going further.

Read blob activity on chain

You can see blob usage in any block with ordinary JSON-RPC. This viem script reads the latest block's blob gas, the current blob base fee and the type-3 transactions that carried blobs:

import { createPublicClient, http } from "viem";import { mainnet } from "viem/chains"; const GAS_PER_BLOB = 131_072n; // 2**17 blob gas per blob (EIP-4844) const client = createPublicClient({ chain: mainnet, transport: http(process.env.RPC_URL) }); const block = await client.getBlock({ blockTag: "latest" });const blobBaseFee = await client.getBlobBaseFee(); const blobs = (block.blobGasUsed ?? 0n) / GAS_PER_BLOB;console.log(`block ${block.number}: ${blobs} blobs`);console.log(`excess blob gas: ${block.excessBlobGas}`);console.log(`blob base fee: ${blobBaseFee} wei per blob gas`); // Which transactions carried them? Type-3 (blob) transactions list their blobs' versioned hashes.const full = await client.getBlock({ blockNumber: block.number, includeTransactions: true });for (const tx of full.transactions) {    if (tx.type === "eip4844") {        console.log(tx.hash, tx.from, `${tx.blobVersionedHashes.length} blobs`, tx.blobVersionedHashes[0]);    }}

Save it as blobs.mts and run RPC_URL=<your Ethereum RPC URL> npx tsx blobs.mts. One run printed:

block 26465368: 1 blobsexcess blob gas: 185410945blob base fee: 7815488 wei per blob gas0x1de992c4442a2c02370d7c1dd251c757365430dd4be98d7faac9b098a9253e6c 0x09d1ad25b369a0c48bdf4caab85afd08a3f07044 1 blobs 0x010953c19db7c2a5809a370f32e001d257f2d7c0137c7fc58352687066861a97

Every versioned hash starts with 0x01, the KZG version byte. The blob contents themselves come from a consensus client's blob or column endpoints, and only for the retention window. If you need an address's transactions, balances or token transfers on Ethereum and the rollups that post to it, rather than the raw blobs, an indexed Ethereum API saves running a node per chain; the supported chains list shows which rollups GoldRush covers.

PeerDAS vs Celestia, Avail and EigenDA

Ethereum isn't the only data availability layer. The main alternatives, in brief:

  • Celestia is a chain built only for ordering and publishing data. It erasure-codes block data in two dimensions and light nodes sample it.
  • Avail also uses KZG commitments with erasure coding, so light clients verify samples against commitments.
  • EigenDA is a service secured by restaked ETH through EigenLayer: operators store pieces of erasure-coded data and attest to holding them. It is not a blockchain of its own.

The trade-off is security against cost and capacity. Data in Ethereum blobs is secured by Ethereum's own validator set, and a rollup that settles on Ethereum and posts its data there takes on no extra trust assumption. An external DA layer can offer separate block space, but the rollup also depends on that layer's validators or operators and on the bridge that tells Ethereum the data was posted. For the full picture of DA layers in a modular stack, see what is a modular blockchain, and for how ZK rollups use the data, how ZK rollups work.

Experiment with the cryptography

To see erasure coding and cell recovery run rather than read about them, the reference functions are in the consensus specs' Fulu folder (compute_cells_and_kzg_proofs, recover_cells_and_kzg_proofs), implemented by the c-kzg-4844 library that clients use. A community project, PeerDAS Playground, wraps these in a small command-line tool that drops a share of cells and recovers them; it is a third-party learning tool, not part of any client.

Frequently asked questions

What is PeerDAS?

PeerDAS (Peer Data Availability Sampling, EIP-7594) is the Ethereum feature that lets nodes confirm blob data is available by downloading and checking a few columns of erasure-coded data from their peers instead of every blob. Any half of the columns can rebuild the full data, so a node that receives its samples can be confident nothing is withheld. It went live in the Fusaka upgrade on 3 December 2025.

What is proto-danksharding (EIP-4844)?

Proto-danksharding is EIP-4844, shipped in Ethereum's Dencun upgrade in March 2024. It added blob-carrying transactions (type 3): rollups attach blobs of 128 KiB of data, committed to with KZG commitments and priced in a separate blob gas market. Blobs are kept by consensus nodes for about 18 days rather than forever, which made posting rollup data much cheaper than using calldata.

How is PeerDAS different from proto-danksharding?

Proto-danksharding created blobs, but every consensus node still downloaded every blob in full, so capacity was limited by node bandwidth. PeerDAS keeps the same blobs, transactions and fee market and changes how nodes check them: blobs are erasure-coded into 128 columns, each node stores a few and samples a few, and KZG cell proofs let it verify each piece. That lets the blob target rise without every node's bandwidth rising with it.

What is Fusaka?

Fusaka is the Ethereum network upgrade that activated on mainnet on 3 December 2025 at epoch 411392. Its name combines Fulu, the consensus layer upgrade, and Osaka, the execution layer upgrade. Its headline change is PeerDAS; it also added blob-parameter-only forks, a floor on the blob base fee, a per-transaction gas cap and a secp256r1 precompile, among others.

Do I need to change anything to run a node after Fusaka?

Run Fusaka-ready releases of both your execution and consensus client. Your consensus client custodies and samples columns automatically: at least 4 custody groups for a node without validators, at least 8 with validators, rising with the stake attached, and all 128 (a supernode) from 4,096 ETH. Nodes with more stake attached use more bandwidth and storage for blob data than small ones.

Did PeerDAS change how long blob data is available?

No. Columns are served for 4,096 epochs, the same as blobs before, which is about 18 days. After that, consensus nodes may prune them. The versioned hashes in the transactions and the KZG commitments in the blocks stay on chain permanently, so anyone holding a copy of the data can prove it matches.

What are BPO forks?

Blob Parameter Only forks (EIP-7892) are small scheduled upgrades that change only the blob target, the blob maximum and the blob base fee update fraction. They let Ethereum raise blob capacity in steps after Fusaka without a full hard fork each time. The first two mainnet BPO forks were scheduled for 9 December 2025 (target 10, max 15) and 7 January 2026 (target 14, max 21).

Is PeerDAS the same as full danksharding?

No. PeerDAS uses one-dimensional erasure coding, extending each blob on its own, and reuses Ethereum's existing gossip network. Full danksharding is the longer-term design that envisages two-dimensional coding and more scalable sampling. PeerDAS was shipped first because it fits the current networking stack.

Next steps

Get new guides by email

New tutorials and best practices for building with blockchain data, sent as they're published.