Blob Budgeting After Pectra: Designing Rollups Around EIP-7691

A pragmatic guide to sizing, scheduling, and pricing your rollup’s data after Ethereum’s Pectra upgrade doubled blob capacity and raised calldata floor costs. We translate the new fee mechanics into concrete budgeting rules, formulas, and checklists your team can ship today.

TL;DR for decision‑makers

On May 7, 2025, Ethereum’s Pectra upgrade activated on mainnet, doubling the blob target to 6 and raising the per‑block max to 9 (EIP‑7691). This reshapes L2 data economics and smooths prices for consistent posting. (blog.ethereum.org)
Calldata is now structurally more expensive for data‑heavy posts (EIP‑7623), so fallback from blobs to calldata only makes sense in rare spikes; we quantify those thresholds below. (eips.ethereum.org)

What changed in Pectra (and why it matters to rollups)

EIP‑7691 raised Ethereum’s blob throughput by setting:

Target blobs per block: 6 (was 3)
Max blobs per block: 9 (was 6)
TARGET_BLOB_GAS_PER_BLOCK: 786,432
MAX_BLOB_GAS_PER_BLOCK: 1,179,648
BLOB_BASE_FEE_UPDATE_FRACTION_PRAGUE: 5,007,716 (new sensitivity) (eips.ethereum.org)

Two operational consequences for rollups:

More headroom: daily blob capacity at max becomes ~7.91 GiB (9 blobs × 128 KiB × ~7200 blocks/day), up from ~5.27 GiB at the old 6‑blob cap. Roughly double the target‑rate capacity (from ~2.64 → ~5.27 GiB/day). (eips.ethereum.org)
Different fee responsiveness: the new 2:3 target:max ratio makes the blob base fee more sensitive when usage is below target. In EIP‑7691’s chosen parameters, a “full blob section” increases the base fee ~8.2% per block, while an empty section decreases it ~14.5%. That’s intentionally asymmetric to recover from quiet periods faster. (eips.ethereum.org)

Calldata also changed. EIP‑7623 introduced a floor price for data‑heavy transactions:

Zero byte: 10 gas/byte (floor)
Non‑zero byte: 40 gas/byte (floor) This reduces worst‑case execution payload size and nudges DA usage to blobs. It’s now harder to make calldata cheaper than blobs unless blob prices spike dramatically. (eips.ethereum.org)

Finally, EIP‑7840 standardized where clients read blob parameters (“blobSchedule”) so fee estimators and node configs track per‑fork values (Cancun → Prague) without Engine API gymnastics. (eips.ethereum.org)

Quick reference: the constants your team should use

Blob size: 131,072 bytes (128 KiB) = 4,096 × 32‑byte field elements. (eips.ethereum.org)
GAS_PER_BLOB: 131,072 blob‑gas per blob. (eips.ethereum.org)
Blobs pruned after ~4096 epochs (~18 days) — plan off‑chain retention. (eips.ethereum.org)
Post‑Pectra “blobSchedule” (EL config): target=6, max=9, baseFeeUpdateFraction=5,007,716. (eips.ethereum.org)

Example client config (do not copy blindly; align with your client’s syntax):

"blobSchedule": {
  "cancun": { "target": 3, "max": 6, "baseFeeUpdateFraction": 3338477 },
  "prague": { "target": 6, "max": 9, "baseFeeUpdateFraction": 5007716 }
}

This matters because fee estimators and analytics (e.g., ratio fields in fee history) depend on per‑fork max/target values. (eips.ethereum.org)

The blob fee market after Pectra: what we’ve observed

Post‑activation, the “blob object” price on the consensus layer fell sharply; Galaxy Research reported a near‑zero median cost per blob object in the first days after Pectra (note: excludes the EL type‑3 tx cost). That indicated ample spare capacity and a smoother auction at the higher target. (galaxy.com)
Volatility can still happen. During 2024 “blobscriptions,” the blob base fee per gas briefly jumped from 1 wei to ~650 gwei per blob gas, but even then blobs typically remained cheaper than calldata most of the time. Pectra’s higher target and EIP‑7623’s calldata floor increase the margin before calldata becomes competitive. (blocknative.com)

Implication: budget for steady blob use (don’t wait for dips), but add guardrails for short spikes.

Budgeting blobs: concrete formulas and break‑even thresholds

Use these three rules to choose between blobs and calldata:

Size your batch first, then derive blobs

Required blobs B = ceil(bytes / 131,072). You pay for padding—fill your blobs. (eips.ethereum.org)

Blob cost per byte equals base_fee_per_blob_gas

Because one blob‑gas maps to one byte (GAS_PER_BLOB = 131,072 for 131,072 bytes).
Total blob fee (wei) = B × 131,072 × base_fee_per_blob_gas. (eips.ethereum.org)

Calldata cost per byte under EIP‑7623 (when the floor binds)

Zero bytes: 10 × base_fee_per_gas
Non‑zero bytes: 40 × base_fee_per_gas
Let f be the non‑zero byte fraction of your compressed batch. The effective calldata cost per byte is:
C_calldata ≈ base_fee_per_gas × [10 × (1 − f) + 40 × f]. (eips.ethereum.org)

Break‑even: choose calldata only if

base_fee_per_blob_gas > base_fee_per_gas × [10 × (1 − f) + 40 × f]

Examples:

If f ≈ 1 (mostly non‑zero), threshold ≈ 40× base_fee_per_gas
If f ≈ 0.5, threshold ≈ 25× base_fee_per_gas
If f ≈ 0 (mostly zeros), threshold ≈ 10× base_fee_per_gas

In the blobscriptions spike, blob base fee hit ~13.3× the execution base fee and blobs were still often cheaper than calldata. With EIP‑7623’s floor, your threshold is typically ≥10× and often ~40×, so blob → calldata switches should be rare and deliberate. (blocknative.com)

A simple “BlobBudgeter” that your sequencer team can implement

Inputs:

backlog_bytes (pending DA to post), max_delay_slots (SLO), f (non‑zero ratio after compression)
base_fee_per_blob_gas_now, base_fee_per_gas_now
recent blobGasUsedRatio[] and baseFeePerBlobGas[] via eth_feeHistory. (docs.metamask.io)

Heuristics based on EIP‑7691 dynamics:

If last N slots were below target (e.g., avg blobGasUsedRatio < 0.66 under 6/9), expect faster price decay (~14.5%/slot when empty). If above target and full, expect slower increases (~8.2%/slot). (eips.ethereum.org)

Pseudocode:

def plan_blob_posts(backlog_bytes, max_delay_slots, f, 
                    base_fee_per_blob_gas, base_fee_per_gas,
                    blobGasUsedRatio, slots_ahead=6):
    bytes_per_blob = 131072
    need_blobs = math.ceil(backlog_bytes / bytes_per_blob)

    # Compute calldata break-even blob gas price
    calldata_per_byte = base_fee_per_gas * (10*(1-f) + 40*f)  # gas per byte
    blob_break_even = calldata_per_byte  # wei per blob-gas

    # Predict blob fee drift using last few slots: crude envelope
    recent = sum(blobGasUsedRatio[-3:])/3 if len(blobGasUsedRatio)>=3 else 0.66
    def next_fee_estimate(fee, used_ratio):
        # Approximations from EIP-7691 rationale
        if used_ratio >= 1.0:   # full blob section
            return fee * 1.082
        if used_ratio <= 0.0:   # empty
            return fee * 0.855
        # linearize between 0 and 1 for a quick proxy
        return fee * (0.855 + 0.227*used_ratio)

    fee_path = [base_fee_per_blob_gas]
    for i in range(slots_ahead):
        fee_path.append(next_fee_estimate(fee_path[-1], recent))

    # Target a smoothed cost: spread posts across S slots, capped by SLO
    S = min(slots_ahead, max_delay_slots, max(1, math.ceil(need_blobs/3)))
    blobs_per_slot = math.ceil(need_blobs / S)

    # Price cap per slot: below both break-even & predicted path
    cap_per_blob_gas = min(blob_break_even * 0.9, min(fee_path))  # 10% safety

    return {
        "slots": S,
        "blobs_per_slot": blobs_per_slot,
        "max_fee_per_blob_gas": int(cap_per_blob_gas),
        "switch_to_calldata_if_blob_gas_over": int(blob_break_even)
    }

Notes:

Read baseFeePerBlobGas and blobGasUsedRatio via
```
eth_feeHistory
```
; both fields are available post‑4844 in many clients/providers. (docs.metamask.io)
Respect type‑3 mempool replacement rules: a 1.1× bump is recommended for blob‑fee replacements, just like EIP‑1559. (eips.ethereum.org)

How many blobs should you buy per batch?

Think in SLOs (maximum acceptable L2→L1 latency) and “cost slope”:

With a 6‑blob target, a few empty slots quickly pull fees down (~−14.5%/slot when empty), so postponing 1–2 slots can materially lower costs.
With full sections, the base fee climbs slower (~+8.2%/slot), so posting consistently at near‑target is cheaper than letting backlog spike into max (9) and triggering several full slots in a row. (eips.ethereum.org)

Practical rule: aim for “near target” consumption, e.g., 4–6 blobs/slot during sustained load, rather than bursts to 8–9.

Worked examples you can plug into your budget

Cost to post ~1 MiB (1,048,576 bytes) of compressed data:

Blobs needed: 8
Blob‑gas total: 8 × 131,072 = 1,048,576 blob‑gas
At 1 wei/blob‑gas: 1,048,576 wei ≈ 0.000001048576 ETH
At 1 gwei/blob‑gas: 0.001048576 ETH
At 100 gwei/blob‑gas: 0.1048576 ETH
Execution‑layer (type‑3 tx) overhead is additional but typically small relative to high blob prices. (eips.ethereum.org)

When should a rollup temporarily fall back to calldata?
Let base_fee_per_gas = 3 gwei:

If f ≈ 1 (non‑zero heavy), break‑even ≈ 40 × 3 = 120 gwei/blob‑gas
If f ≈ 0.5, break‑even ≈ 25 × 3 = 75 gwei/blob‑gas
If f ≈ 0 (mostly zeros), break‑even ≈ 10 × 3 = 30 gwei/blob‑gas
Given historic spikes reached ~650 gwei/blob‑gas only during extreme events, calldata remains the exception—especially with the EIP‑7623 floor. (blocknative.com)

Operational checklist (post‑Pectra)

Node/client readiness
- Ensure your EL/CL clients are on Pectra‑ready releases (mainnet activation was May 7, 2025, epoch 364,032). (blog.ethereum.org)
- Confirm “blobSchedule” parameters are present in your EL chain config (target=6, max=9, baseFeeUpdateFraction=5,007,716). (eips.ethereum.org)
Fee estimation & monitoring
- Consume
```
eth_feeHistory
```
  with baseFeePerBlobGas and blobGasUsedRatio for the last 20–100 blocks; build percentile‑aware caps. (docs.metamask.io)
- Alert on: base_fee_per_blob_gas > (25–40)× base_fee_per_gas (depending on f), backlog_bytes > threshold, and rising reorg rate during spikes.
Mempool & replacement policy
- Implement a 1.1× bump for blob‑fee replacements to avoid stuck postings. (eips.ethereum.org)
Data retention & retrieval
- Because blobs are pruned ~18 days after inclusion, maintain redundant off‑chain storage and index by commitment/versioned hash; test recovery frequently. (eips.ethereum.org)

Packaging data efficiently for 128 KiB blobs

Fill every blob: you pay for 128 KiB even if underfilled—batch until blobs are ~100–127 KiB after compression.
Compression: prefer fast, frame‑friendly codecs (zstd low‑mid levels) and binary encodings that minimize non‑zero density if you expect calldata fallback; a lower non‑zero fraction f lowers your calldata break‑even threshold.
Homogeneous batches: mixing very sparse and dense segments increases variance; separate them to stabilize f and your cost model.

How Pectra changes your sequencing strategy

Aim to post near target (4–6 blobs/slot) during steady load. That keeps you close to the auction’s “equilibrium” and reduces long‑run variance thanks to the asymmetric update fraction. (eips.ethereum.org)
Smooth your postings across slots rather than end‑of‑epoch bursts; with the higher target, a couple of quiet slots can materially reset the base fee downward (~14.5% per empty slot).
Keep an automated “calldata breaker” but gate it with the formula above; most teams will rarely cross 25–40× thresholds in practice after Pectra + EIP‑7623. (eips.ethereum.org)

Tooling tips (engineering teams)

Expose these signals in your Grafana dashboards:
- base_fee_per_blob_gas (next‑slot from feeHistory) and %Δ over last 8–16 slots
- blobGasUsedRatio (last 64 slots) vs. target (6/9 = 0.666…)
- Backlog bytes → “blobs required” at current compression ratio
- Calldata break‑even thresholds for f ∈ {0.25, 0.5, 0.75, 1.0}
Store both EL tx and CL blob object receipts; when investigating anomalies, compare EL inclusion vs. CL gossip timings.
Validate your replacement logic by submitting test type‑3 txs that intentionally under/overbid and ensuring your 1.1× bump logic takes effect. (eips.ethereum.org)

What’s next to watch (so your budget model stays current)

EIP‑7918 (Last Call): proposes a reserve price coupling blob base fee to execution gas cost, bounding the blob market below by a fraction of EL cost. This would reduce pathological underpricing and change break‑even math—keep your estimators modular. (eips.ethereum.org)
EIP‑7762 (Review): raising MIN_BASE_FEE_PER_BLOB_GAS to speed price discovery and optionally resetting excess_blob_gas at fork points—this would lift the blob price floor. (eips.ethereum.org)
PeerDAS: the likely path to much higher DA without linear bandwidth growth—longer‑term, it will change capacity/risk assumptions again. The EF has flagged this direction as the scaling path beyond Pectra. (blog.ethereum.org)

Executive takeaways

Budget for blobs as your default DA: Pectra’s 6/9 and EIP‑7623’s calldata floor make blobs the steady‑state choice. Spikes can happen, but the asymmetric update and higher target mean prices fall quickly when demand eases. (eips.ethereum.org)
Implement a simple, automated “BlobBudgeter” that smooths purchases, caps bids using feeHistory, and only flips to calldata at mathematically justified thresholds.
Treat node configs and fee estimators as “per‑fork aware” systems; use EIP‑7840’s blobSchedule and monitor blobGasUsedRatio to stay in lockstep with the protocol. (eips.ethereum.org)

How 7Block Labs can help

We design and run blob‑aware sequencers and fee engines for production rollups. If you need:

A hardened BlobBudgeter with percentile‑based caps and SLA‑aware smoothing,
Dashboards and alerts wired to baseFeePerBlobGas / blobGasUsedRatio,
Benchmarks for your compression pipeline and non‑zero ratios (f), or
End‑to‑end DA retention and recovery with pruned‑after‑18‑days blobs,

we can partner with your team to ship in weeks, not months.

Sources and further reading

EIP‑7691: Blob throughput increase (parameters, fee responsiveness). (eips.ethereum.org)
Pectra mainnet activation (May 7, 2025, epoch 364,032). (blog.ethereum.org)
EIP‑7623: Increase calldata cost (10/40 floor for data‑heavy txs). (eips.ethereum.org)
EIP‑4844: Proto‑Danksharding (blob size, GAS_PER_BLOB, pruning window, fee formula). (eips.ethereum.org)
EIP‑7840: Blob schedule in EL configs (per‑fork target/max/update fraction). (eips.ethereum.org)
Blocknative on blobscriptions and blob price spikes (context for volatility). (blocknative.com)
Galaxy on post‑Pectra blob object costs (early observations). (galaxy.com)
Execution API feeHistory fields for blobs (baseFeePerBlobGas, blobGasUsedRatio). (docs.metamask.io)