Blob-First Rollups: Re-architecting Data Availability After EIP-7691

Summary: Ethereum’s May 7, 2025 Pectra upgrade implemented EIP-7691, doubling blob capacity and reshaping the economics of Layer 2 data availability. This post translates the change into concrete architecture, pricing math, and rollout playbooks for decision‑makers building on or evaluating rollups. (blog.ethereum.org)

TL;DR for decision‑makers

EIP‑7691 increased Ethereum’s blob target/max from 3/6 to 6/9 blobs per block, with a more responsive fee curve, materially expanding L1 data availability (DA) for rollups. (eips.ethereum.org)
In the first week post‑fork, actual blob demand ran below the new target; blob “object” fees collapsed toward zero again, lifting L2 margins even when end‑user fees didn’t drop further. (galaxy.com)
“Blob‑first” architectures—batching to fill blobs, dynamic blob/calldata switching, and multi‑DA fallbacks—now deliver lower, more predictable costs and better resilience than pre‑7691 designs. (docs.arbitrum.io)

1) What EIP‑7691 changed—and why it matters

EIP‑7691, part of Pectra on May 7, 2025, raised Ethereum’s blob throughput by moving the target/max blobs per block to 6/9 and updated the blob base‑fee responsiveness. Practically: more “blobspace,” less scarcity, and faster fee decay when demand dips. Key parameters and effects: (blog.ethereum.org)

Target blobs per block: 6 (was 3)
Max blobs per block: 9 (was 6)
Update fraction changed, making base‑fee react asymmetrically: when blocks are full the blob base‑fee rises ~8.2% per full block, but with empty sections it falls ~14.5%—deliberately biased toward keeping prices low unless consistently saturated. (eips.ethereum.org)

Blobs themselves come from EIP‑4844 (Dencun, March 13, 2024), which introduced a separate DA lane for rollups with ~128 KiB per blob and an ~18‑day availability window at the consensus layer. (eips.ethereum.org)

Result after Pectra: daily blob capacity rose from roughly 5.5 GB/day to ~8.15 GB/day. In the first five to seven days, rollups purchased ~25.6k blobs/day (≈3.3 GB/day), still below the new target rate—hence “virtually free” blob object costs and materially lower net L2 DA spend. (galaxy.com)

For executives, the takeaway is simple: Ethereum’s primary DA got bigger and (on average) cheaper again, improving L2 margins and headroom without changing your settlement chain.

2) The blob market after 7691: what the numbers say

Capacity: 6/9 target/max blobs × 128 KiB each translates to higher sustained DA headroom. (eips.ethereum.org)
Usage and price: Post‑Pectra, demand jumped ~20–22% but remained below target, pushing blob object fees toward negligible levels and reducing ETH burned from L2 DA by ~70% week‑over‑week in early data. (galaxy.com)
Node pressure: With more blobs purchased, consensus nodes retained an estimated peak ~44.6 GB of blob data across the 18‑day window. Capacity remained manageable, but monitoring is prudent. (galaxy.com)

At the user level, many L2s had already passed EIP‑4844 savings through (e.g., cents‑level fees on Optimism/Base). 7691 primarily widens the runway and stabilizes costs for sequencers and L2 operators. (coindesk.com)

3) Blob‑first architecture: how modern L2s should post data now

Blob‑first means treating Ethereum blobspace as your default DA target, optimizing the batcher/derivation pipeline around blob fullness, and only falling back to calldata (or external DA) when economically justified or operationally necessary.

3.1 Embrace blob‑native batching and packing

Fill rate: Engineer your batcher to target ≥95% fullness per blob. After encoding, the effective payload per blob is ≈127,228 bytes (vs. the raw 131,072 bytes), so tune frame sizing/headers to leave small safety headroom. (gist.github.com)
Compression tuning: Balance zstd level and CPU budget to hit near‑full blobs without raising latency. Arbitrum Nitro’s docs explicitly frame the trade‑off: higher compression lowers L1 posting costs at the expense of throughput headroom. (docs.arbitrum.io)
Time vs. size triggers: Implement dual thresholds (e.g., flush when ≥98% of effective blob payload OR after X seconds) to avoid under‑filled blobs during low traffic.

3.2 Price‑aware blob vs. calldata switching

Why it matters: Even with 7691, short bursts can spike blob base‑fees. Your batcher should compare:
- Blob cost = baseFeePerBlobGas × GAS_PER_BLOB + EL type‑3 tx gas,
- vs. Calldata bytes × (4/16 gas per byte, or higher if 7623/7976 are live on the network you settle to). (eips.ethereum.org)
Implementation patterns:
- Arbitrum exposes explicit toggles like post‑4844‑blobs and an ignore‑blob‑price flag to force blobs or permit fallback when cheaper. This is an archetype worth mirroring in custom stacks. (docs.arbitrum.io)
- OP Stack’s Ecotone upgrade added a new L1 data fee pricing function and updated the L2 GasPriceOracle—use this pattern to push accurate L1 DA costs into your sequencer economics and user‑facing fee quotes. (gov.optimism.io)

3.3 Use the right signals in your oracle

On L1 (Ethereum), contracts and off‑chain services can read the blob fee with:
- BLOBBASEFEE opcode (EIP‑7516), returning the current base fee per blob gas in‑block for programmatic accounting. (eips.ethereum.org)
- eth_feeHistory fields baseFeePerBlobGas and blobGasUsedRatio for forward‑looking estimation (e.g., sliding windows across N latest blocks). (docs.metamask.io)
On L2s like Linea, BLOBBASEFEE may be stubbed at a minimum; don’t rely on L2 opcodes for L1 pricing—query L1 directly when computing DA costs. (docs.linea.build)

3.4 Operate a resilient Beacon‑aware data layer

Since blobs are a consensus‑layer artifact referenced by EL, your nodes need healthy Beacon connectivity to retrieve blob sidecars; OP Stack emphasizes running or peering to a consensus client (Lighthouse, Prysm, Teku, etc.). Bake this into production runbooks. (docs.optimism.io)
Retention planning: Blobs are pruned after ~4096 epochs (~18 days). Maintain independent archival of batch payloads well past that horizon (for reorg/litigation windows) and instrument alerts when sampling or retrieval degrades. (ethereum.org)

4) Pricing the new world: exact math and planning ranges

Use explicit formulas in your treasury and sequencer logic.

Constants: GAS_PER_BLOB = 2^17; bytes per blob = 4096 × 32 = 131,072 bytes; effective payload ≈127,228 bytes. (eips.ethereum.org)
Blob object cost (ETH per blob) = baseFeePerBlobGas (in wei) × 131,072 / 1e18. Example sensitivity:
- At 1 wei (the protocol minimum), cost ≈ 1.31e‑13 ETH per blob—de minimis. (eips.ethereum.org)
- At 1 gwei, ≈ 0.000131072 ETH per blob. At 50 gwei, ≈ 0.0065536 ETH per blob. Use your ETH/USD to plan, and remember to add the EL execution gas of the type‑3 transaction.
Calldata fallback cost = (zeroBytes × 4 + nonZeroBytes × 16) gas today; expect higher floors (10/40 gas per byte under EIP‑7623; possibly 15/60 under EIP‑7976) as the ecosystem nudges DA to blobs. Factor these in when designing your switch thresholds. (eips.ethereum.org)

Emerging market tweaks: minimum blob base‑fee proposals (EIP‑7762) and related designs (EIP‑7918) aim to speed price discovery and bound blob fees during demand spikes. They have modest average cost impact but change tail behavior—model these in stress tests. (eips.ethereum.org)

5) Interop with alternative DA: why “blob‑first,” not “blob‑only”

Ethereum blobspace is improving quickly (PeerDAS is on the roadmap to further scale DA), but specialized DA layers (EigenDA, Celestia, Avail) remain relevant for extreme throughput and cost predictability targets. A pragmatic 2026‑ready strategy is “blob‑first with multi‑DA fallback.” (eips.ethereum.org)

When to prefer external DA:
- You require sustained multi‑MB/s posting (e.g., high‑TPS chains) where even post‑PeerDAS Ethereum may be throughput‑constrained; several teams (e.g., MegaETH) choose EigenDA for this reason. (megaeth.com)
- You want pricing predictability decoupled from L1 fee cycles or need faster finality trade‑offs. Track L2BEAT’s DA throughput dashboard to understand who posts where today. (l2beat.com)
Architecture pattern:
- Default to Ethereum blobs; if baseFeePerBlobGas × blobsNeeded breaches your SLO budget—or Beacon endpoints degrade—route to secondary DA with a proof/attestation recorded on L1. Ensure merklized payloads are consistent across DA backends. (docs.arbitrum.io)

6) What the leading stacks are doing (and what to copy)

Arbitrum: Productionized blob posting with explicit config to force blobs or fall back to calldata; useful operational flags include ignore‑blob‑price and blob‑tx replacement timing/caps. Actionable template for proprietary batchers. (docs.arbitrum.io)
OP Stack (Ecotone): Added a new L1 data fee function and upgraded GasPriceOracle; run a Beacon client and adapt your fee oracle to consume blob metrics via eth_feeHistory. (gov.optimism.io)
Base/OP/Arbitrum: After Dencun, major L2s saw fees compress to cents. Post‑7691, operators captured further margin even when end‑user fees stayed flat, indicating room to invest savings into reliability or growth. (coindesk.com)

7) Operational playbook and SLIs/SLOs

Instrument these metrics and guardrails in your blob‑first rollout:

SLI: Blob fullness (target ≥95%); under‑filled blobs <5% of daily volume.
SLI: Blob posting failure rate (<0.1%); mean time to replace (RBF) for type‑3 submissions.
SLI: Beacon availability (p95 sidecar retrieval latency <2s; error rate <0.5%).
SLO: Cost per batch under three traffic tiers (low/med/high), with thresholds derived from baseFeePerBlobGas percentiles from eth_feeHistory. (docs.metamask.io)

Operational controls:

Dual‑trigger flush (size/time) and adaptive compression levels. (docs.arbitrum.io)
Automatic blob/calldata routing based on live cost comparison and latency budget. (docs.arbitrum.io)
Cold‑path re‑publisher: if Beacon retrieval fails, re‑publish the batch payload to an auxiliary store (object storage + content addressing) for independent auditors until proof windows close. (ethereum.org)
Canary posting at low frequency to continuously validate Beacon RPCs and commitment verification even during off‑peak.

8) Compliance and risk considerations for enterprises

Retention guarantees: Ethereum guarantees blob availability for ~18 days. If your dispute window exceeds that, maintain independent archival and audit trails. (ethereum.org)
Regulatory evidence: Because blobs are pruned, your compliance evidence must reference L1 commitments plus your off‑chain payload store. Audit that hash chains tie unambiguously to what was posted via type‑3 tx. (eips.ethereum.org)
Change management: Track calldata repricing (EIP‑7623 live on some networks; EIP‑7976 proposed) and minimum blob fee proposals (EIP‑7762). These influence your fallback economics and stress‑event behaviors. (eips.ethereum.org)

9) What’s next on the roadmap (and how to prepare)

PeerDAS (EIP‑7594): data availability sampling via the P2P layer is in Last Call, targeting an order‑of‑magnitude DA scale‑out without overwhelming nodes. Expect higher blob targets over time; design your batcher to scale with parameter increases. (eips.ethereum.org)
Uncoupling parameters (EIP‑7742) means the execution layer reads the blob target from the consensus layer, enabling faster future adjustments—engineers should avoid hardcoding assumptions in fee oracles. (eips.ethereum.org)
Ethereum is likely to continue steering DA demand from calldata to blobs; plan for calldata floors to increase (7623→7976) and keep your fallback path on a short leash. (eips.ethereum.org)

10) A concrete 30‑60‑90 day plan

Days 1–30:
- Add blob fullness, baseFeePerBlobGas, and blobGasUsedRatio dashboards; wire eth_feeHistory in your fee oracle. (docs.metamask.io)
- Enable blob posting in staging with forced‑blob mode; verify near‑full packing and end‑to‑end blob sidecar retrieval. (docs.arbitrum.io)
Days 31–60:
- Roll out price‑aware routing (blob vs. calldata), with escalation to secondary DA only on policy breaches; validate accounting using BLOBBASEFEE in L1‑aware components. (docs.arbitrum.io)
- Tune compression and flush thresholds to keep under‑filled blobs under 5%.
Days 61–90:
- Introduce multi‑DA pilot (e.g., EigenDA/Celestia) with L1 commitments and deterministic batch hashes; run failure‑injection drills on Beacon outages. (l2beat.com)

11) FAQ: common executive questions

Will user fees drop again after 7691?
Maybe, but not necessarily. Early data shows blob object fees fell to near‑zero because demand is below target, but many L2s kept end‑user fees stable and captured margin. That cushion can fund growth, rebates, or reliability. (galaxy.com)
Is calldata still relevant?
Yes—as a resilient fallback and for non‑DA uses—but Ethereum governance is clearly nudging DA to blobs (7623/7976). Blob‑first is the default; calldata is the safety valve. (eips.ethereum.org)
How do we monitor blob fees?
Use BLOBBASEFEE (on L1) for in‑block accounting and eth_feeHistory’s baseFeePerBlobGas/blobGasUsedRatio for forecasting. (eips.ethereum.org)

Key references

EIP‑7691: blob throughput increase; target/max 6/9; fee responsiveness details. (eips.ethereum.org)
Pectra mainnet activation (May 7, 2025). (blog.ethereum.org)
Blob market post‑Pectra (capacity, usage, near‑zero object costs, node retention). (galaxy.com)
Dencun (EIP‑4844) blob size and 18‑day availability window. (eips.ethereum.org)
Arbitrum/OP Stack blob operations and pricing oracles. (docs.arbitrum.io)
Calldata repricing and future DA scale (EIP‑7623/7976, PeerDAS EIP‑7594). (eips.ethereum.org)

Closing thought

EIP‑7691 didn’t just make blobs bigger—it made blobspace a strategic default. For startups and enterprises, a blob‑first rollup that fills blobs intelligently, prices routes dynamically, and maintains a multi‑DA escape hatch will enjoy lower costs, higher margins, and smoother operations as Ethereum’s DA roadmap (PeerDAS and beyond) comes online. (eips.ethereum.org)

7Block Labs helps teams design, implement, and operate blob‑first pipelines, fee oracles, and multi‑DA integrations. If you’re planning a migration or greenfield L2, now is the time to build with blobs at the center.