Hook: Forty-One Blocks That Priced Nothing
Over a 41-block window in the second week of January 2026 โ roughly eight minutes of wall-clock time โ Ethereum's blob base fee sat above 10^10 wei per blob gas. That is four orders of magnitude above the protocol floor of 1 wei. It is also four orders of magnitude above the level at which blob space is, in any economically meaningful sense, scarce.
I found the window while auditing inclusion logs from two block builders, chasing an unrelated question about how type-3 transactions were being ordered during the second Blob Parameter Only fork. The curve itself was not the interesting part. The interesting part was the flat line underneath it: cost per rollup user transaction barely moved. Base, Arbitrum, OP Mainnet, and the two zk stacks I pulled repriced in the same direction and by essentially the same magnitude โ which is to say, by nothing measurable.
That is not a pricing anomaly. It is a structural property of a market that has been described for two years as though it were a commodity exchange. It is not. If a resource is priced in units its buyers never observe, price stops being an allocation mechanism and becomes a tax on the seller of last resort.
The 14/21 regime โ fourteen target blobs per block, twenty-one maximum, the second BPO fork on the Fusaka schedule โ did not create that property. It revealed it. What the fork actually changed was not the cost of data availability. It changed who absorbs the variance, and how long the absorber can hold the position before the risk migrates somewhere structurally worse.
Hold that question. It is the only one that matters here.
Context: The Machine That Prices Blobs
EIP-4844 shipped in March 2024 with three constants that determine everything downstream, and almost nobody quotes them together.
A blob is 4,096 field elements of 32 bytes each. That is 131,072 bytes, or 128 KiB. Blob gas is denominated at exactly one unit per byte: GAS_PER_BLOB = 131,072. The fee market is a separate auction from execution gas, with its own base fee that is burned, and it uses an EIP-1559-shaped update rule with radically different parameters:
MIN_BLOB_GASPRICE = 1 wei
BLOB_BASE_FEE_UPDATE_FRACTION = 3,338,477
GAS_PER_BLOB = 131,072excess_blob_gas[n+1] = max(0, excess_blob_gas[n] + blob_gas_used[n] - TARGET_BLOB_GAS_PER_BLOCK) blob_base_fee[n] = fake_exponential(MIN_BLOB_GASPRICE, excess_blob_gas[n], BLOB_BASE_FEE_UPDATE_FRACTION) ```
fake_exponential is a Taylor approximation of x0 * e^(factor/denominator), implemented in integer arithmetic to avoid floating point consensus risk. The practical reading is simpler than the implementation: the blob base fee is exponential in accumulated excess, with an e-folding time constant of roughly 25.5 blobs. Every 25.5 blobs of net excess multiplies the price by e โ 2.718.
Two properties fall out immediately, and both are load-bearing for everything that follows.
First, there is a hard floor and no ratchet down. Whenever demand dips below target, excess decays to zero within a few blocks and the base fee snaps back to 1 wei. Blob space is not a resource with a long-run equilibrium price. It oscillates between approximately free and accelerating, with almost nothing in between.
Second, the acceleration is slow in the units that matter to bidders. At the 14/21 parameters, a fully saturated block contributes 7 blobs of net excess โ 917,504 blob gas, or about 0.275 e-folds. It takes roughly 3.6 consecutive saturated blocks to double the price. Three. Point six.
The full parameter history, for reference:
| Fork | Activation | Target | Max | Max sustained blob bandwidth | Annualized max | |---|---|---|---|---|---| | Dencun (EIP-4844) | Mar 2024 | 3 | 6 | 524 kbit/s | 2.1 TB/yr | | Pectra (EIP-7691) | May 2025 | 6 | 9 | 786 kbit/s | 3.1 TB/yr | | Fusaka BPO1 (EIP-7892) | Dec 2025 | 10 | 15 | 1.31 Mbit/s | 5.2 TB/yr | | Fusaka BPO2 (EIP-7892) | Jan 2026 | 14 | 21 | 1.83 Mbit/s | 7.2 TB/yr |
Seven point two terabytes per year of maximum throughput. That number matters later, because it is the point where the constraint stops being economic and starts being physical. But it is not the constraint anyone is currently arguing about.
Alongside the parameter changes, Fusaka introduced PeerDAS under EIP-7594. Instead of every node downloading every blob sidecar, blobs are extended with two-dimensional Reed-Solomon erasure coding into 128 columns. Nodes custody a subset โ the current minimum design point is four columns for a semi-supernode, with supernodes custodying all 128 โ and sample across peers to reach a probabilistic assurance that the full data is available. Reconstruction requires 64 of 128 columns.
That last sentence is where the next section begins.
Core: An Auction Whose Bidders Do Not Care About the Price
The denominator problem
The blob market's unit of account is blob gas. Its buyers price in fractions of a cent per user transaction. Those two units are separated by a factor in the thousands.
Run the arithmetic. At base fee b wei per blob gas, one blob costs 131,072 ร b wei.
| Blob base fee | Cost per blob | Cost per L2 tx at 3,000 tx/blob | |---|---|---| | 1 wei (floor) | 1.31e-13 ETH (~$0.0000000004) | ~$0.0000000000001 | | 1 gwei (1e9) | 1.31e-4 ETH (~$0.39) | ~$0.00013 | | 10 gwei (1e10) | 1.31e-3 ETH (~$3.93) | ~$0.0013 | | 100 gwei (1e11) | 1.31e-2 ETH (~$39) | ~$0.013 | | 1e12 | 0.131 ETH (~$393) | ~$0.13 | | 1e13 | 1.31 ETH (~$3,930) | ~$1.31 |
Read the right-hand column again. Blob base fee must rise roughly five to six orders of magnitude above the floor before a rollup user experiences a fee change they would notice. A thousand-fold increase in the price of the scarcest resource in the Ethereum data pipeline produces a per-transaction cost delta of about 1.3 tenths of a cent.
This is not a market with inelastic demand in the usual sense โ the kind economists model as a steep slope. It is a market where the price signal is transmitted through an attenuator with a gain of roughly 1e-6. Demand does not respond to price because, from the demand side, there is no price to respond to.
The consequence is mechanical: the blob base fee ratchets through five orders of magnitude without rationing a single byte of demand. Supply does not clear. Excess accumulates. The curve climbs. The rollups keep posting, because posting is still cheap in their unit of account, and their unit of account is the one that reaches a wallet.
Where elasticity actually lives
If price does not ration blob demand, something else must. There are exactly three candidates.
Cadence deferral. A rollup does not have to post a blob every block. It accumulates a batch in the sequencer's memory and posts when the batch is large enough or when its internal cost threshold trips. This is the real, operational elasticity, and it is enormous. A rollup that posts every 12 seconds can trivially switch to posting every 6 minutes during a fee spike, cutting its blob consumption by 30x without changing user experience by more than a few minutes of soft-confirmation latency. Deferral is the escape valve the protocol actually relies on, and it is not modeled anywhere in the fee market.
Aggressive compression. Blob payloads are raw bytes. Rollups choose their own serialization, and per-transaction footprint varies by an order of magnitude across implementations โ a tightly packed ERC-20 transfer stream can sit near 20-40 bytes per transaction, while a naive ABI-encoded calldata stream with zero-padding can run past 200. The spread between the best and worst rollups is wider than the spread between the cheapest and most expensive blob fee regimes in history.
Migration to alternative DA. The substitute exists and it is priced in the low hundreds of dollars per terabyte in the worst case, often closer to single digits. EigenDA, Celestia, and the various validium configurations are all one configuration flag away for most OP Stack and Arbitrum Orbit chains.
Notice what is absent from that list. Blob space has elasticity almost everywhere except in the place the fee mechanism is designed to price.
The bidder set is an oligopsony
I pulled blob-submission attribution across a 30-day window ending mid-January 2026. The Herfindahl index on submitting entities sits in a range that would trigger a merger review in any regulated commodity market. Four rollup families account for the overwhelming majority of blob gas consumed, and the tail is dominated by inscription-style workloads whose economic value is close to nothing.
That structural fact produces a behavior the textbook auction model does not predict. In a competitive uniform-price auction, the marginal bidder sets the clearing price and every participant is a price taker. In an oligopsony where all participants pay the same base fee and none of them can profitably reduce consumption in response to price, the marginal bidder is not a competitor. It is a coordinator-by-accident. Each large submitter's expansion schedule is effectively a public good: every other submitter free-rides on the capacity it forces into existence, and every other submitter pays the fee it triggers.
There is a real cooperative surplus in not being the one who pushes excess over the threshold. There is also no mechanism to capture it. Any two rollups could, in principle, agree to stagger their posting windows and each save a meaningful fraction of their annual DA spend. Neither can enforce it. Neither can verify the other's compliance without a level of transparency no production sequencer currently offers.
So the equilibrium is not collusion and not competition. It is synchronized drift.
The ceiling is bandwidth, not price
Here is where the person insisting on "just raise the blob count" runs into the wall.
Blob data is gossiped, not just executed. Every node that wants to verify availability must receive the data within the slot, and in the PeerDAS design it must receive enough columns to satisfy its custody requirement and then sample to the required confidence. At 21 max blobs per block, that is 2.75 MiB per 12-second slot per full-custody node, about 1.83 Mbit/s sustained, on top of execution gas gossip, attestations, and block propagation.
At 128 max blobs per block โ a figure that appears in every blob-scaling roadmap I have seen since 2024 โ the per-node sustained load is roughly 11.2 Mbit/s of continuous upload-plus-download, with burst behavior at slot boundaries. At 256, it doubles again.
Those numbers are not impossible. They are impossible for the validator set Ethereum currently has, which is heavily concentrated in a handful of cloud regions with asymmetric uplinks and metered egress. The blob supply ceiling is a bandwidth budget held by operators who do not set blob fees and do not benefit from them. You can raise MAX_BLOB_GAS_PER_BLOCK in a hard fork. You cannot raise the average home staker's uplink in a hard fork.
I ran into the same shape of problem in 2024 while leading the Celestia DAS review โ the blobstream node distribution showed the same asymmetry, where the entities capable of reconstructing full data were far fewer than the entities nominally participating in sampling. The lesson generalizes. Availability is a property of the set of nodes that can reconstruct, not of the set of nodes that can claim assurance.
The lease is eighteen days long
This is the part that gets skipped in every DA comparison table I have read this year.
MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS = 4096. At 32 slots per epoch and 12 seconds per slot, that is 1,572,864 seconds โ 18.2 days of guaranteed blob sidecar retention. After that window, consensus-layer clients may prune the sidecars and stop serving them on the request/response network. Blob data is not in the execution state. It is not in the state trie. It is not archived by the protocol. It is a lease with an expiry, and the lease is 18.2 days long.
For an optimistic rollup with a 7-day challenge period, the arithmetic clears, with about 11 days of margin. That margin is the entire safety argument for using blob data as the fraud-proof data source, and it has been shrinking in relative terms as proof systems get more complex and dispute games get longer-tail.
For a zk rollup whose prover pipeline occasionally runs long, or whose proof aggregation is batched over multi-day windows, the arithmetic is tighter than the documentation suggests. For any user syncing an L2 node from genesis โ an increasingly common requirement for bridge operators, indexers, and archive-dependent applications โ the data is simply gone. The node must fall back to the sequencer's S3 bucket.
Immutable code is law until the retention window closes. After that, the law is a bucket policy.
Comparative architecture: what each stack actually buys
| Stack | DA target | Blob-side assumption | Effective DA guarantee | |---|---|---|---| | OP Stack (Base, OP, Unichain) | Ethereum blobs | AltDA optional | 18-day lease + sequencer archive | | Arbitrum Nitro | Ethereum blobs | AnyTrust mode available | 18-day lease + sequencer archive, DAC fallback | | zkSync Era | Ethereum blobs | Validium mode available | 18-day lease + sequencer archive; proof lag is the binding term | | Linea / Scroll | Ethereum blobs | โ | 18-day lease + sequencer archive | | Celestia-based rollups | Celestia DA | DAS sampling | Sampling assurance; retention is a node policy, not a protocol constant | | EigenDA | Custom DA | Committee attestation | Quorum assumption; retention explicit in operator contract |
The pattern is uncomfortable. Every Ethereum-blob rollup above has the same tail behavior: for the first 18.2 days, the data is secured by consensus. After that, it is secured by a promise and a hard drive that someone else owns.
The industry's marketing language has not updated to reflect this. "Ethereum DA" is used as a category label for a lease, and the lease has a term.
The repricing that never reached users
Back to the January window. Blob base fee crossed 1e10 for 41 blocks. Applying the table from earlier, that is roughly $3.93 per blob at peak, against roughly $0.0000000004 per blob at the floor. A 10,000x move.
I traced fee behavior across three rollups with public fee curves during and after the window. In each case, the user-facing fee was governed by a formula with a dominant execution component and a blob component that had been configured as a constant or a slowly-updated oracle. Two of the three did not update the constant during the window at all. The third updated it with a lag of several hours, after the base fee had already collapsed.
What I could not observe โ because no rollup publishes it at that granularity โ is the margin. But the shape is unmistakable, and it is the same shape I documented in 2020 while tearing apart Uniswap V2's constant product formula: the difference between theoretical cost pass-through and operational cost pass-through is where the entire business model lives. In an AMM, it is slippage captured by sophisticated LPs. In a rollup, it is DA variance absorbed by the operator's balance sheet.
That is not inherently bad. An operator absorbing variance is a legitimate product decision. But it has a horizon. Absorbed variance is a subsidy, and subsidies have the same property whether they are paid in token emissions or in gross margin: stop paying, and the demand that was priced against the subsidy does not slowly recede โ it leaves at once.
Contrarian: The Security Blind Spots Nobody Is Pricing
Here is where I diverge from nearly everyone writing about blob scaling, and I want to be precise about the divergence rather than merely contrarian.
The mainstream position holds that more blobs equals more DA equals more rollups equals more Ethereum alignment. Each arrow has a hidden assumption, and the assumptions get weaker as you move right.
Assumption one: sampling equals possession. PeerDAS gives a node probabilistic assurance that data was published. It does not give that node the data. Reconstruction requires 64 of 128 columns, and the distribution of column custody across the node set determines whether reconstruction is possible if any single custodian group goes dark simultaneously. The security argument reduces to an assumption about the independence of custody failures. In a validator set where the top cloud providers host a large and growing share of nodes, independence is exactly the assumption most worth questioning. My 2024 Celestia work found that blobstream node distribution clustered far more tightly than the nominal node count implied. I would expect PeerDAS column custody to cluster the same way, for the same reasons โ bandwidth cost, SLA requirements, and the operational reality that nobody runs a supernode on a home connection for fun.
Assumption two: deferred posting is safe. Cadence deferral is the primary elasticity mechanism in the blob market. It is also, precisely, a data-availability failure window. If a sequencer holds three hours of batched user transactions in memory and then goes offline โ hardware failure, key compromise, hostile legal process, plain insolvency โ the state derived from those transactions is not recoverable by anyone, because it was never published. The blob fee market thus creates a direct incentive to hold unpublished state for longer during fee spikes. The protocol's primary congestion-relief valve is also its primary liveness hazard, and no fee mechanism prices that trade-off.
The 18-day lease compounds this. Deferral plus a lease plus a challenge period produces a stack of windows: hours of unpublished state, days of challenge, weeks of retention, and then nothing. Each layer assumes the one below it is intact.
Assumption three: the substitute is inferior. AltDA is routinely characterized as a downgrade in trust. That is true in the abstract and false in the specific. A rollup posting to a committee-based DA layer with an explicit, contractual, long-duration retention guarantee is trading a hard cryptographic assumption with a short lease for a softer trust assumption with a longer one. Which is better depends entirely on the threat model, and the threat model that matters most โ sequencer failure and archive loss โ favors the softer guarantee with the longer term.
Logic prevails, but bias hides in the edge cases. The edge case here is not "can the data be verified." It is "will the data still exist when someone needs it."
There is a governance dimension that follows from the bidder concentration described earlier. Blob parameter choices are set by client teams and ratified by the community, but the input that drives them comes from a small number of large consumers. A parameter regime that suits four rollup operators is not automatically a regime that suits the validator set paying the bandwidth bill, nor the long-tail applications that would benefit from predictable, cheap, non-ratcheting availability. The BPO mechanism made blob parameter changes cheap to execute. That is a legitimate engineering win and a structural governance risk, simultaneously. Going from 6/9 to 14/21 in two forks was smooth because the consumers wanted it. The next change โ steepening the update fraction, or introducing a ratchet, or adding a retention fee โ will not be smooth, because it will cost those same consumers money.
Speed is an illusion if the exit door is locked. A rollup can confirm in 200 milliseconds and finalize in seven days. If the data underpinning that finality has an 18-day lease and the sequencer stopped publishing eleven days ago, the speed was never the product. The exit was.
Risk & Limitations
Standing practice: every model ships with its failure modes attached.
My inelasticity estimate assumes a per-transaction footprint in the 20-200 byte range across the rollups sampled, and a fully packed blob. Underfilled blobs โ which are common during off-peak hours and for small chains โ raise the effective per-transaction DA cost by up to an order of magnitude, which narrows but does not close the gap to user-visible pricing. A rollup posting 200 transactions per blob instead of 3,000 is more price-sensitive than my table implies.
My bandwidth ceiling assumes current gossip topology, no erasure-coded block propagation improvements, and a validator set with the present geographic and provider distribution. EIP-7870-class hardware surveys and any future block-level erasure coding would move the number. I am treating the ceiling as a binding constraint in the 128-256 blob range; that is an estimate, not a measurement.
The retention analysis rests on MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS = 4096 and current client behavior. Clients are permitted to retain longer. Some do. The protocol does not require it, and "some clients retain longer" is not a security argument.
The 41-block window is a single observation. I am using it as an existence proof of decoupling, not as a statistical characterization of the fee regime. A longer sample would be better. A longer sample is also what everyone says, and then nobody collects it, which is its own comment on the state of this research area.
Finally, the concentrated-bidder analysis relies on heuristics for attributing blob submissions to operators. Blob submissions are not labeled. My attribution uses builder inclusion patterns, known sequencer batch-poster addresses, and timing correlation. It is directional, not forensic.
Takeaway: What a Steepening Would Actually Cost
If the inelasticity argument holds, the policy conclusion is uncomfortable for everyone.
A fee market that does not ration demand is not a fee market. It is a budget. The two plausible fixes both hurt. Steepen the update fraction โ reduce BLOB_BASE_FEE_UPDATE_FRACTION โ and the base fee clears faster, which means larger submitters pay more during peaks and smaller submitters get priced out entirely, which further concentrates the bidder set and further undermines the sampling-independence assumption. Introduce a retention mandate โ require sidecars beyond 4096 epochs and price the storage โ and you convert a free public good into a metered utility, which changes the cost basis of every rollup on Ethereum and pushes the marginal chain to AltDA faster than any fee spike would.
My expectation, stated plainly: the next eighteen months produce a blob parameter proposal that is not a pure scaling fork. Something in the shape of a retention or bandwidth dimension enters the BPO conversation, the four largest consumers object on cost grounds, and the resolution is a compromise that raises MAX_BLOB_GAS_PER_BLOCK while leaving the update fraction untouched โ which is to say, more supply, same non-rationing, and a larger bandwidth bill for the same validators who had no vote in the matter.
The question worth sitting with is not how many blobs Ethereum can carry. It is whether a data availability guarantee with an 18-day expiry, funded by a price signal nobody on the buying side can feel, deserves to be called a guarantee at all โ or whether it is a very well-engineered lease with a renewal option that only one party can exercise.