A blob (binary large object), specifically an EIP-4844 proto-danksharding blob, is a dedicated data packet attached to an Ethereum block that provides cheap, temporary data availability for layer 2 rollups. Unlike calldata, which is stored permanently on-chain, blob data is automatically deleted by nodes after approximately 18 days, drastically reducing the long-term storage burden and cost. This mechanism allows rollups like Optimism and Arbitrum to post transaction proofs and data at a fraction of the previous cost, directly lowering fees for end-users.
Blob
What is a Blob?
A blob is a large, temporary data package introduced in Ethereum's Dencun upgrade to reduce transaction costs for layer 2 rollups.
The technical architecture involves a new transaction type that carries a blob-carrying transaction. Each transaction can include up to six blobs, with each blob holding roughly 128 KB of compressed data. This data is not executed by the Ethereum Virtual Machine (EVM) but is made available for a short period, allowing layer 2 networks to verify the integrity and correctness of their off-chain transactions. The separation of data availability from execution is a core innovation, paving the way for the full implementation of danksharding in the future.
From a network perspective, blobs are validated and propagated through a new peer-to-peer network sub-protocol, ensuring all consensus nodes can access the data during the critical window. Validators are incentivized to include blobs through a separate fee market, the blob gas fee market, which operates independently from the standard gas for execution. This creates a more stable and predictable pricing model for rollup data, decongesting the main Ethereum block space and enabling higher scalability for the entire ecosystem.
Etymology & Origin
The term 'blob' in blockchain, specifically **EIP-4844**, has a precise technical origin that diverges from its common computing usage, representing a fundamental data structure for scaling.
In blockchain, a blob (Binary Large Object) is a dedicated data packet introduced by Ethereum's EIP-4844 (Proto-Danksharding) to carry temporary, low-cost transaction data for Layer 2 rollups. The term was chosen for its established meaning in computer science—a large, opaque binary data block—but is re-contextualized as a blob-carrying transaction with specific size (≈128 KB) and lifecycle constraints. Its primary function is to separate bulky data from the main execution layer, enabling cheaper data availability for rollups without permanently burdening Ethereum's consensus nodes.
The conceptual origin of the blob is directly tied to the roadmap for Danksharding, a future scaling upgrade. Proto-Danksharding (EIP-4844) implemented a simplified, interim version of this architecture. The blob's design—being large, committed to via a KZG commitment, and automatically pruned after a short period (≈18 days)—stems from the need to provide a data availability layer that is cost-effective for rollups while ensuring the historical data can be stored by specialized actors like blob archivers. This creates a clear separation between data for immediate verification and data for long-term storage.
The etymology reflects a deliberate shift from previous data structures. Prior to EIP-4844, rollups posted their transaction data as calldata on the main chain, which was permanent and expensive. The blob is a new, first-class citizen in the Ethereum protocol, with its own transaction type and fee market. Its name succinctly captures its role: a large, self-contained binary object whose contents are only interpreted by Layer 2s, while the Ethereum consensus layer merely attests to its availability.
Key Features
Blobs (Binary Large Objects) are a dedicated data storage mechanism on Ethereum, designed to provide a low-cost, high-volume data layer for Layer 2 rollups.
Data Availability
A blob is a packet of data (up to ~128 KB) posted to the consensus layer that is not accessible to the Ethereum Virtual Machine (EVM). Its primary purpose is to guarantee data availability for Layer 2 rollups, ensuring anyone can reconstruct the rollup's state and verify its proofs. The data is only stored for a short period (~18 days) before being pruned by nodes.
EIP-4844 (Proto-Danksharding)
Blobs were introduced via EIP-4844, also known as Proto-Danksharding. This upgrade created a new transaction type, blob-carrying transactions, which attach these data blobs. It is a precursor to full Danksharding, establishing the foundational architecture for a scalable, separate data layer on Ethereum without executing the data.
Fee Market & Blob Gas
Blob transactions consume a new type of resource called blob gas, which has a separate fee market from standard EVM execution gas. This decoupling prevents competition for block space between rollup data posting and regular user transactions, leading to more predictable and stable costs for Layer 2 data availability.
KZG Commitments
Each blob is accompanied by a KZG commitment (a polynomial commitment). This cryptographic proof allows nodes to verify that the blob data is available and correct without downloading the entire blob. Clients store only the small commitment (~48 bytes) long-term, enabling efficient data availability sampling for future scaling.
Rollup Scaling
Blobs are the cornerstone for scaling Ethereum via Layer 2 rollups (Optimistic and ZK). By posting transaction data in blobs instead of calldata, rollups reduce their data posting costs by ~10-100x. This directly lowers transaction fees for end-users on rollups like Arbitrum, Optimism, and zkSync.
Historical Storage & EIP-4444
While nodes prune blob data after ~18 days, historical data remains accessible. EIP-4444 proposes that execution clients stop serving historical data older than one year, pushing this responsibility to decentralized storage networks (like Ethereum Portal Network) or data availability layers. This reduces node hardware requirements.
How It Works
A blob is a temporary, low-cost data packet used to post transaction data to the blockchain, enabling scalable rollup solutions.
A blob (Binary Large OBject) is a dedicated data structure introduced by Ethereum's EIP-4844 (Proto-Danksharding) to provide temporary data availability for Layer 2 rollups. Unlike traditional transaction calldata, which is stored permanently on-chain, blob data is only accessible for a short period (approximately 18 days) and is not processed by the Ethereum Virtual Machine (EVM). This design allows rollups to post large batches of transaction data at a significantly lower cost, as the network only needs to guarantee the data's availability for verification, not its indefinite storage.
The mechanism relies on a new transaction type, blob-carrying transactions, which include a reference to the blob data in a sidecar. This data is stored in the Beacon Chain consensus layer within the blobspace, a separate resource market from standard gas. Validators are responsible for attesting to the availability of this data for a short window, after which it can be pruned. This separation of execution and data availability is the core innovation, dramatically reducing the cost for rollups to settle their data on Ethereum while maintaining the security guarantees of the base layer.
For developers, blobs are accessed via the BLOBHASH opcode and the blobVersionedHashes field in a transaction. A rollup sequencer will typically compress its batch of transactions, generate KZG commitments for the data, and post it as a blob. The associated KZG commitment (a cryptographic proof) is what is permanently recorded on-chain, allowing anyone to verify the data was available if needed. This system ensures that fraud proofs or validity proofs for rollups can be executed correctly, as the necessary data was publicly accessible at the time of posting.
The practical impact is a new scaling paradigm. By creating a high-bandwidth, low-cost data lane, blobs enable rollups to post more data per block, which translates to higher transaction throughput and lower fees for end-users. This architecture is a critical stepping stone towards full Danksharding, a future upgrade that will further expand blob capacity by distributing data across a committee of validators, solidifying Ethereum's roadmap for scalable, secure settlement.
Blob vs. Calldata
A technical comparison of Ethereum's two primary methods for storing transaction data post-EIP-4844 and EIP-4844.
| Feature | Calldata (Legacy) | Blob (EIP-4844) |
|---|---|---|
Primary Purpose | Execute contract logic | Store large, temporary data for Layer 2s |
Storage Location | Permanently on Ethereum execution layer | Temporarily in Beacon Chain consensus layer |
Persistence | Permanent (full history) | ~18 days (pruned after) |
Gas Cost Model | Priced per byte (16 gas per non-zero) | Priced per blob (base fee + priority fee) |
Cost Efficiency for L2s | Low (expensive for bulk data) | High (orders of magnitude cheaper) |
Data Access | Fully accessible to EVM via | Not accessible to EVM; verified via KZG commitments |
Max Size per Transaction | Block gas limit constrained | ~128 KB per blob (3 blobs/tx max) |
Network Scaling Benefit | Minimal | High (decouples L2 data posting cost from execution gas) |
Ecosystem Usage
Following its introduction with EIP-4844, blobs have become a foundational data primitive for scaling Ethereum's Layer 2 ecosystem, enabling cheaper transaction data availability.
EIP-4844: Proto-Danksharding
EIP-4844, known as Proto-Danksharding, is the Ethereum upgrade that introduced the blob-carrying transaction type. It created a new transaction format and a separate fee market for blob data, laying the groundwork for full Danksharding.
- New Transaction Type: A transaction can carry up to 6 blobs (~0.75 MB total).
- Blob Gas Market: A separate EIP-1559-style fee market for blob space, decoupled from execution gas.
- KZG Commitments: Uses KZG polynomial commitments to allow nodes to verify blob data efficiently without downloading it all.
Blob Data Structure & Lifecycle
A blob is a large packet of data (~128 KB) attached to a beacon block. Its lifecycle is managed by the consensus layer to optimize node resource usage.
- Composition: Contains the calldata from L2 rollup transactions.
- Commitment & Proof: Each blob has a KZG commitment and proof, allowing for cryptographic verification of its contents.
- Storage & Pruning: Full blob data is stored by all consensus nodes for approximately 18 days (4096 epochs). After this period, only the commitment is retained, and the data can be safely discarded, reducing long-term storage burdens.
Impact on Rollup Economics
Blobs have fundamentally changed the cost structure for Layer 2 rollups, making high-throughput, low-cost applications economically sustainable on Ethereum.
- Fee Reduction: By moving data to a cheaper resource (blob space), L2 transaction fees have dropped significantly post-EIP-4844.
- Predictable Pricing: The separate blob gas market provides more stable and predictable data posting costs for rollup sequencers.
- Enabling Scale: Lower data costs allow rollups to support more users and transactions without exponentially increasing costs, directly enabling broader adoption.
Client Implementation & Tooling
Support for blobs required upgrades across the entire Ethereum client stack and the development of new tooling for builders.
- Consensus Clients: Must validate KZG commitments, store blobs, and serve them via the Blob Sidecar.
- Execution Clients: Process blob-carrying transactions, paying blob gas, and making blob data available to the EVM via the
BLOBHASHopcode. - Developer Tools: Libraries like EIP-4844 APIs and upgraded RPC endpoints (e.g.,
eth_getBlobSidecars) allow applications to submit and retrieve blob data.
Future: Full Danksharding
Proto-Danksharding (EIP-4844) is a stepping stone to full Danksharding, which will massively increase blob capacity and decentralize data storage.
- Increased Capacity: Target of 64 blobs per block (up from 6), enabling ~8 MB of data per slot.
- Data Availability Sampling (DAS): Light clients and nodes will be able to verify data availability by sampling small random pieces of blobs, enhancing scalability and decentralization.
- Blob Persistence: Specialized blob archivers may emerge to store historical blob data long-term for applications that require it.
Security & Design Considerations
While blobs offer significant scalability benefits, their implementation introduces new security vectors and design trade-offs that developers and network participants must understand.
Data Availability & Censorship Resistance
The core security guarantee of a blob is data availability (DA)—ensuring the data is published and retrievable for a sufficient window. If blob data is withheld, nodes cannot verify the validity of the associated transactions, breaking the chain's security model. This makes blob propagation networks and peer-to-peer (P2P) gossip protocols critical components. Design considerations include the blob retention period (e.g., EIP-4844's ~18 days) and the economic incentives for nodes to store and serve data.
Blob Gas Market & Spam Prevention
Blobs consume a separate resource called blob gas, governed by its own fee market (similar to EIP-1559). This prevents congestion in blob usage from spiking standard transaction gas fees. Key mechanisms include:
- Target and maximum blob gas per block to limit throughput.
- Blob base fee that adjusts dynamically based on network demand.
- Priority fees (tips) for validator inclusion. Attackers could attempt to spam the network with blobs, so the gas pricing must economically disincentivize filling blocks with worthless data.
Blob Verification & Fraud Proofs
Light clients and rollups rely on the assumption that blob data is available. Data availability sampling (DAS) allows light nodes to probabilistically verify availability by downloading small random chunks. If data is missing, fraud proofs or data availability proofs can be submitted to the L1 to slash the malicious validator or builder. The system's security depends on having at least one honest node that sampled the missing data and can generate a proof.
Long-Term Storage & Pruning
Blobs are designed for short-term data availability, not permanent on-chain storage. After the retention period, nodes can safely prune the blob data. This creates a data lifecycle management challenge. Applications using blobs must ensure critical data is moved to persistent storage (like a rollup's own data availability layer or decentralized storage networks) before pruning occurs. The security of the system post-pruning relies on the assumption that the data was available long enough for all necessary parties to retrieve it.
MEV and Builder Considerations
Blobs introduce new dimensions for Maximal Extractable Value (MEV). Block builders must now manage the packaging and ordering of both standard transactions and blobs. This could lead to:
- Blob frontrunning: Anticipating and exploiting data published in blobs.
- Censorship: Builders excluding certain blobs.
- Resource competition: Blobs competing with transactions for block space in the builder's construction process. Proposer-Builder Separation (PBS) designs must account for blob handling to maintain network neutrality and security.
Upgrade Paths and Forward Compatibility
Blob designs like EIP-4844 (proto-danksharding) are often incremental steps toward a full vision (e.g., danksharding). This requires careful forward-compatible design. For example, the blob versioned hash includes a commitment version byte, allowing the underlying data format and cryptographic commitment scheme (like KZG commitments) to be upgraded in the future without breaking existing transactions. Security audits must consider both the current implementation and the transition mechanisms to future, more complex systems.
Evolution: From Proto-Danksharding to Danksharding
This section details Ethereum's phased approach to scaling data availability, tracing the technical progression from the initial prototype to the full, multi-dimensional vision.
The evolution from Proto-Danksharding (EIP-4844) to full Danksharding represents Ethereum's incremental roadmap for implementing data availability sampling (DAS), a core scaling technology. Proto-Danksharding, also known as blob-carrying transactions, introduced a new transaction type and a separate fee market for large data packets called blobs. This initial phase established the foundational architecture—including the blob gas mechanism and a beacon chain-managed data layer—without yet implementing the peer-to-peer sampling that defines full sharding. It served as a critical production testbed, allowing the network and its clients to adapt to the new data paradigm while delivering immediate scaling benefits through rollups.
The key technical bridge between these phases is the implementation of data availability sampling. In Proto-Danksharding, validators and clients must download the entirety of each blob to verify its availability. Full Danksharding will decentralize this responsibility: each participant will only need to download a few small random samples of the total data. By collectively sampling the data availability committee (DAC)-less shard data, the network can statistically guarantee its availability without any single node handling the full dataset. This shift transforms data verification from a mandatory full-download task into a lightweight, scalable process, enabling the shard data block size to safely increase by orders of magnitude.
Full Danksharding culminates this vision by scaling the system to 64 data shards, with each proposing a blob in every slot. The proposer-builder separation (PBS) framework, particularly through MEV-Boost and eventual in-protocol PBS, is crucial for managing the immense data load. A specialized block builder will be responsible for constructing a block containing all this shard data, while the consensus layer validators focus on attestations and sampling. This final stage aims to provide massively scalable, low-cost data availability for layer 2 rollups, solidifying Ethereum's settlement layer as a robust foundation for a global, decentralized ecosystem of scalable applications.
Frequently Asked Questions
Common questions about Ethereum's Blob-Carrying Transactions and EIP-4844, which introduced a new data layer to scale the network.
A blob (Binary Large OBject) is a dedicated data packet introduced by EIP-4844 (Proto-Danksharding) that is attached to an Ethereum transaction but stored separately from the main execution layer. A blob is a large chunk of data (up to ~128 KB) that is posted to the Beacon Chain consensus layer, where it is made available for a short period (currently ~18 days) for Layer 2 rollups to use as cheap, temporary data storage. The key innovation is that blob data is not accessible to the Ethereum Virtual Machine (EVM); it is only committed to via a KZG commitment, allowing its validity to be verified without the execution layer processing the full data. This design dramatically reduces the cost for rollups to post transaction data, which is the primary driver of Ethereum scaling.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.