EIP-7691 Cost Curves: Modeling Blob Fee Volatility for App Teams

Summary: EIP-7691 doubled Ethereum’s target blob capacity and retuned the fee update curve, changing how blob base fees rise and fall block-to-block. This guide shows decision‑makers how to model the new cost dynamics, quantify volatility scenarios, and harden posting strategies before fees spike.

Who should read this

Product and engineering leaders at L2s, rollup-based apps, and data-heavy protocols planning L1 DA budgets.
CTOs/CFOs modeling total cost of ownership (TCO) across blob DA vs calldata and alternative DA options.
Platform teams operating batchers, provers, or settlement pipelines sensitive to blob pricing swings.

1) What changed with EIP‑7691 (Pectra): parameters and their business impact

On May 7, 2025, Ethereum’s Pectra upgrade activated EIP‑7691 on mainnet, increasing blob throughput and adjusting the fee responsiveness of the blob market. Concretely: target blobs per block moved from 3 → 6, the per‑block max from 6 → 9, and the blob base fee update fraction was retuned. (blog.ethereum.org)

EIP‑7691 also intentionally breaks the symmetric up/down response of the EIP‑4844 curve:

With 3/6 (pre‑Pectra): full blob sections increased blob base fee ≈12.5%/block; empty sections decreased ≈11.1%/block.
With 6/9 + a new update fraction (post‑Pectra): full blobs increase ≈8.2%/block; empty blocks decrease ≈14.5%/block.
This skew favors faster price declines when demand is under target, and slower price rises when demand is over target—smoothing peaks and accelerating dips. (eips.ethereum.org)

Why it matters:

Your “time to double” during hot surges lengthens, while “time to halve” during lulls shortens.
Budgets, alerts, and max_fee_per_blob_gas guardrails calibrated for 3/6 need re‑tuning for 6/9 to avoid accidental refusal-to-post or overspending.

2) The blob fee engine you’re optimizing against

Blob pricing is an EIP‑1559‑style market independent from execution gas:

GAS_PER_BLOB = 2^17 = 131,072 blob‑gas per blob.
The base fee per blob gas is computed via a “fake exponential” using excess_blob_gas and an update fraction; the fee is burned.
MIN_BASE_FEE_PER_BLOB_GAS = 1 wei. (eips.ethereum.org)

Pectra (via EIP‑7691) plugs new per‑fork values into this same function:

TARGET_BLOBS_PER_BLOCK = 6
MAX_BLOBS_PER_BLOCK = 9
BLOB_BASE_FEE_UPDATE_FRACTION (Prague) = 5,007,716
These values are now managed per‑fork via a “blobSchedule” (see EIP‑7840), enabling clean parameter updates in future forks without custom engine handshakes. (eips.ethereum.org)

What you pay for a blob:

Cost per blob (ETH) ≈ base_fee_per_blob_gas × 131,072.
Blob txs still pay regular execution base/priority fees for the small execution wrapper, but the data payload itself prices in blob gas.

3) Cost curve intuition under 6/9: “how fast can this move?”

Under EIP‑7691’s tuned curve:

If a sequence of empty‑blob blocks hits, blob base fee falls ≈14.5% per block (geometric). A 50% drop takes ~4–5 empty blocks.
If a sequence of maxed blocks hits (9 blobs), blob base fee rises ≈8.2% per block. A 2× increase takes ~9 full blocks.
These back‑of‑envelope “half‑life” and “doubling‑time” estimates are practical for alerting and treasury forecasts; the exact evolution is governed by the exponential rule in EIP‑4844, but the above percentages come from the EIP‑7691 parameterization. (eips.ethereum.org)

Key implications:

Short lulls quickly erase prior spikes—don’t over‑hedge for long at-the-top conditions.
Spikes take longer to build; your posting SLA can often ride out brief heat without breaching max caps, if guards are set correctly.

4) Reserve price bounding: the next lever (EIP‑7918, “price floor” tied to L1 gas)

A recent proposal, EIP‑7918 (Last Call at the time of writing), adds a reserve price so the blob base fee cannot effectively be “ignored” when execution gas dominates costs. It introduces a constant BLOB_BASE_COST (currently 2^13 in the EIP) and enforces: blob price per blob ≥ BLOB_BASE_COST × base_fee_per_gas (per unit of execution gas), expressed in blob‑gas terms. Practically, the reserve blob base fee maps to about 1/16 of the execution base fee, by design. (eips.ethereum.org)

What this means for your models:

If execution base fee is 16 gwei, the reserve blob base fee per blob‑gas is ≈1 gwei; a full blob costs ≈131,072 gwei (0.000131072 ETH), before tips.
The mechanism delays fee drops when execution gas is expensive, stabilizing equilibrium formation; when execution base fee spikes suddenly, blob fees may “lag” for a few blocks but converge smoothly. (eips.ethereum.org)

Note: there has been active discussion on the exact BLOB_BASE_COST constant (e.g., 2^14 considered), but the EIP currently specifies 2^13; plan for calibration risk until mainnet parameters are finalized. (notes.ethereum.org)

5) Real‑world volatility drivers you must price in

Non‑L2 bursts can dominate: the “blobscription” frenzy (early April 2024) pushed blob base fee from 1 wei to ~650 gwei within ~10 minutes (~600 blocks). Even then, blobs largely remained cheaper than calldata, but the discount narrowed materially. Your guardrails must tolerate rare, acute spikes. (blocknative.com)
Post‑Pectra supply overhang: With 6/9 live since May 7, 2025, average blobs per block have often sat below the new target, making blob fees effectively “free” again at times—an environment where costs trend to the floor until demand returns. Don’t let this lull reset your risk memory. (galaxy.com)

6) BPO forks and per‑fork blob schedules: why planning horizons change

Two recent efforts make blob capacity more “governable” over time:

EIP‑7840 (blobSchedule): execution clients carry per‑fork blob parameters (target, max, baseFeeUpdateFraction). This is why Pectra could cleanly use 6/9 and a new update fraction in Prague/Electra without complicated per‑block messaging. (eips.ethereum.org)
EIP‑7892 (Blob Parameter Only hardforks): defines surgical “blob‑only” forks that change just target/max/updateFraction, letting Ethereum scale DA faster with less coordination risk. For app teams, it shortens the feedback loop between observed blob demand and parameterization—expect more frequent, lower‑risk changes. (eips.ethereum.org)

Translation for budgets: your 18–24‑month forecasts should include step‑wise capacity increases (and potentially retuned responsiveness) that move the equilibrium, not just organic demand shifts.

7) Scenario modeling: cost curves you can run today

Below are practical modeling patterns your finance/platform teams can adopt.

7.1 Block‑by‑block simulator (spreadsheet or Python)

Inputs:

Sequence of blobs_used per block (0–9 post‑Pectra).
Fork params: target=6, max=9, baseFeeUpdateFraction=5,007,716; GAS_PER_BLOB=131,072; min_blob_base=1 wei. (eips.ethereum.org)

State per block:

excess_blob_gas_t = max(0, excess_blob_gas_{t-1} + blobs_used_t × 131,072 − target × 131,072).
base_fee_per_blob_gas_t = fake_exponential(1, excess_blob_gas_t, baseFeeUpdateFraction).
If simulating a future “reserve price” regime, enforce base_fee_per_blob_gas_t ≥ (BLOB_BASE_COST × base_fee_per_gas_t) / GAS_PER_BLOB. (eips.ethereum.org)

Each block’s blob cost = base_fee_per_blob_gas_t × 131,072 (ETH), times number of blobs posted by your batcher.

Pseudocode:

GAS_PER_BLOB = 2**17
TARGET = 6
UPDATE_FRACTION = 5_007_716
MIN_BLOB_BASE = 1  # wei

def fake_exponential(factor, numerator, denominator):
    i = 1
    output = 0
    numerator_accum = factor * denominator
    while numerator_accum > 0:
        output += numerator_accum
        numerator_accum = (numerator_accum * numerator) // (denominator * i)
        i += 1
    return output // denominator

def step(parent_excess, parent_basefee_blob_gas, blobs_used, basefee_exec_gas=None, reserve_cost=None):
    parent_excess = max(0, parent_excess + blobs_used*GAS_PER_BLOB - TARGET*GAS_PER_BLOB)
    bf_blob = fake_exponential(MIN_BLOB_BASE, parent_excess, UPDATE_FRACTION)
    # Optional: reserve price (EIP-7918)
    if reserve_cost:
        bf_blob = max(bf_blob, (reserve_cost * basefee_exec_gas) // GAS_PER_BLOB)
    cost_per_blob = bf_blob * GAS_PER_BLOB
    return parent_excess, bf_blob, cost_per_blob

Where reserve_cost is BLOB_BASE_COST (e.g., 2**13), and basefee_exec_gas is the EIP‑1559 base fee for execution gas. (eips.ethereum.org)

7.2 Volatility envelopes for guardrails

Up‑swing envelope: assume 9 blobs for N consecutive blocks; apply ≈+8.2% compounding to estimate how many blocks to breach a spending cap or SLA.
Down‑swing envelope: assume 0 blobs; apply ≈−14.5% compounding to estimate time‑to‑recover from a spike.
Use these in alerting: e.g., “If 9‑blob streak lasts >9 blocks, raise max_fee_per_blob_gas by 2× or switch to staggered posting.” (eips.ethereum.org)

7.3 Blob vs calldata “flippening” threshold

Calldata prices per byte at 4–16 gas/byte (zero/non‑zero) at the execution base fee. Blob data effectively prices ≈1 blob‑gas per byte at the blob base fee. During the April 2024 surge, blob gas remained cheaper than calldata even with blob base fee ≈13.3× execution base fee; still, the margin narrowed to within ~19% on specific blobs—set a contingency threshold to spill small batches to calldata only if your SLA is at risk. (blocknative.com)

8) Practice‑proven tactics to tame cost and variance

Batch shaping with fill efficiency targets:
- Aim for ≥97–99% blob fill (waste <1–3%); your price is per blob, not per byte.
- Adopt a “fill‑or‑wait” policy with a cap on worst‑case wait time (e.g., 20–40s) to keep latency within UX tolerances while reducing waste. (eips.ethereum.org)
Time‑shifting posts:
- If your usage is elastic, favor posting during cooling periods. With ≈14.5%/block decay when under target, waiting 4–5 empty‑ish blocks can halve costs without violating settlement SLAs. (eips.ethereum.org)
Quantile‑based fee caps:
- Derive p95/p99 of simulated base_fee_per_blob_gas under expected load; set max_fee_per_blob_gas accordingly to minimize failure to post.
Market‑aware reserve modeling:
- If/when EIP‑7918 lands, tie your minimum expected blob base fee to execution base fee: reserve ≈ (BLOB_BASE_COST/GAS_PER_BLOB) × base_fee_per_gas ≈ base_fee/16 using the current EIP constant. This prevents ridiculous underbids in high‑gas regimes. (eips.ethereum.org)
Multi‑track fallback:
- Define a playbook for rare spikes: switch to smaller, more frequent blobs; dynamically compress harder; or—if absolutely necessary—temporarily spill small deltas to calldata when the price gap collapses. The April 2024 episode is your worst‑case rehearsal. (blocknative.com)
Monitoring you should already have:
- base_fee_per_blob_gas and excess_blob_gas, per block.
- blobGasUsedRatio (via eth_feeHistory), which requires clients to know per‑fork max, now standardized in blobSchedule (EIP‑7840). (eips.ethereum.org)

9) Post‑Pectra reality check: what the market did

In the days after May 7, 2025, daily blob purchases by rollups rose ~20.8% versus the prior 60‑day average (≈21,200 → ≈25,600 per day), but average blobs per block still remained below the new 6‑blob target. Effect: blob prices were near the floor again, with the “smoothing” of 6/9 keeping peaks at bay. Don’t extrapolate today’s cheapness forever; it’s a capacity and responsiveness story, not a promise of zero cost. (galaxy.com)

10) Worked examples for decision‑makers

Example A: posting at 16 gwei execution base fee with reserve price (future EIP‑7918 world)
- Reserve blob base fee per blob‑gas ≈ 16 gwei / 16 = 1 gwei → ~0.000131072 ETH per full blob.
- If you post 5 blobs per block for 100 blocks, reserve‑only burn ≈ 5 × 0.000131072 × 100 = 0.065536 ETH (excluding execution wrapper and tips). This is your “can’t go lower” spend in tight gas regimes. (eips.ethereum.org)
Example B: surge tolerance during a 9‑blob streak
- Starting from 1 gwei blob base fee, after 9 full blocks the fee ≈ 1×(1.082)^9 ≈ ~1.99 gwei. Your per‑blob ETH burn doubles in ~2 minutes—configure batchers to split across time or add quantile headroom. (eips.ethereum.org)
Example C: decay after a lull
- From 2 gwei to ~1 gwei needs ~5 empty-ish blocks at −14.5% each. If your SLA tolerates ~1–1.5 minutes of delay, you can halve costs. (eips.ethereum.org)

11) Implementation checklist (what to ask your team for)

Instrumentation
- Collect per‑block: blobs_used, base_fee_per_blob_gas, excess_blob_gas, execution base fee, blobGasUsedRatio.
- Alert when a 9‑blob moving window ≥ N blocks (e.g., N=6) or when base_fee_per_blob_gas exceeds your p95.
Simulation & budgeting
- Maintain a rolling 30/90‑day Monte Carlo using your observed demand + worst‑case exogenous spikes (calibrated to the 2024 blobscription event). (blocknative.com)
- Produce p50/p95/p99 burn forecasts under 6/9; refresh whenever fork parameters change (via blobSchedule). (eips.ethereum.org)
Policy
- Codify a volatility playbook: thresholds to split batches, shift timing, or activate calldata fallback; define caps for max_fee_per_blob_gas under “peak” and “extreme” regimes.
Readiness for parameter‑only forks
- Track EIP‑7892 so your ops plan expects small, frequent blob parameter changes that can shift equilibria or responsiveness without other protocol churn. (eips.ethereum.org)

12) FAQ for CFOs and program managers

Are blobs “permanently cheap” post‑Pectra?
No. Pectra raised capacity (target 6, max 9), which reduced scarcity and smoothed price movements. Volatility still exists; the curve now falls faster when under‑used and rises more gradually when stressed. (eips.ethereum.org)
Will the protocol actively pin blob prices to execution gas?
Possibly. EIP‑7918 is in Last Call and would add a reserve price roughly tied to 1/16 of execution base fee at current constants, stabilizing markets when execution costs dominate. Plan ahead, but treat constants as subject to update before activation. (eips.ethereum.org)
Did Pectra actually launch, and when?
Yes—May 7, 2025 (epoch 364032). If your models use “go‑live” data, anchor to that date. (blog.ethereum.org)

13) Bottom line

EIP‑7691 doesn’t just add space; it retunes incentives so prices drop faster during lulls and ramp more slowly during peaks.
Use the 6/9 curve math to set alerting and hedging: ≈−14.5%/block on the way down, ≈+8.2%/block on the way up.
Prepare for reserve‑price coupling to execution gas (EIP‑7918) and for more frequent, lightweight blob parameter forks (EIP‑7892) that can shift equilibria.

If you want help turning this into a production‑ready simulator and batcher policy, 7Block Labs can deliver a model, dashboards, and implementation guidance in under two weeks.

References and further reading

EIP‑7691: Blob throughput increase (target 6, max 9; update fraction; asymmetry of up/down moves). (eips.ethereum.org)
EIP‑4844: Blob fee computation, GAS_PER_BLOB, fake_exponential, and header fields. (eips.ethereum.org)
EIP‑7840: blobSchedule parameters per fork (target, max, baseFeeUpdateFraction). (eips.ethereum.org)
EIP‑7892: Blob Parameter Only hardforks—predictable, surgical scaling of blob capacity. (eips.ethereum.org)
EIP‑7918: Reserve price tied to execution gas; delayed response rationale and empirical analysis. (eips.ethereum.org)
Pectra mainnet activation (date/time; client releases). (blog.ethereum.org)
Volatility case study: first EIP‑4844 congestion event (“blobscription” spike). (blocknative.com)
Post‑Pectra market: blob purchases up ~20.8%, average usage below target → near‑floor prices. (galaxy.com)