At about 09:47 UTC on 12 November 2026, a transaction sent to the batch inbox address of Base landed in Ethereum block 26,398,055 with six blobs attached, the data packets created by EIP-4844. Together they could hold 768 KiB of compressed Base transactions. Ethereum charged 0.00000359 ETH for the six blobs, about 0.0000006 ETH or roughly 0.12 US cent per blob at the Etherscan price of about $2,043.50 at 09:50 UTC. The same transaction also paid for 21,000 units of ordinary gas, and that part cost about 0.0000068 ETH, close to 1.4 cents. The envelope cost nearly twice as much as the six blobs inside it, and about 11 times as much as any one of them.
That receipt is what EIP-4844 built. The proposal, also called proto-danksharding and live on Ethereum since the Dencun upgrade of 13 March 2024, did not make Ethereum execute more transactions. It opened a separate, temporary lane for rollup data, with its own unit of gas and its own price, and that lane is the main reason a blockchain, where users swap tokens directly from their own wallets without handing custody of their funds to a company.">swap on Base or Arbitrum now costs a fraction of a cent. How cheap that lane stays now depends on two settings changed since launch: the number of blobs a block can carry, 14 on target since January 2026, and a reserve price added in December 2025 that ties the blob fee to ordinary gas.
The rollup basics are in our lesson on how layer 2 rollups make Ethereum cheaper: a rollup executes transactions away from Ethereum, posts compressed data and a claimed result back to it, and charges its users for their own execution plus a share of that posting cost. How the claim gets checked differs. Optimistic rollups wait for a challenge; ZK rollups attach a proof, the subject of the previous lesson, ZK rollups explained. Both need their data published where anyone can read it, and that is the part blobs repriced.
Before EIP-4844, rollups bought calldata at full gas prices
Until Dencun, a rollup had one place to put its batches on Ethereum: the calldata of an ordinary transaction. Calldata is the input bytes of a call. Every full node downloads it, it is priced in the same gas as computation, and it stays in the chain’s history for good. Our guide to gas, the base fee and EIP-1559 explains how that gas is priced, and why calldata became dearer again with the EIP-7623 floor of 2025.
Rollups never needed that permanence. Their data has to be public long enough for anyone to rebuild the chain’s state or to contest a wrong result. After that, the result is settled on Ethereum and the raw bytes only matter to whoever wants the history. Paying for eternal storage of data that matters for days was the waste the Dencun upgrade set out to remove.
The authors said so plainly. The proposal, created on 25 February 2022 by Vitalik Buterin, Dankrad Feist, Diederik Loerakker (known as protolambda), George Kadianakis, Matt Garnett, Mofi Taiwo and Ansgar Dietrichs, opens its motivation with the claim that rollups are, in the short and medium term, “the only trustless scaling solution for Ethereum”. At the time, it noted, Optimism and Arbitrum charged fees only “~3-8x lower” than Ethereum itself. It called itself “a stop-gap solution” until full data sharding. The name, as ethereum.org explains, joins the two researchers who proposed the idea, protolambda and Dankrad Feist.
A rough calculation shows the scale of the change. One blob holds 131,072 bytes. Posted as calldata, those bytes cost at least 16 gas each when they are not zero, about 2.1 million gas per blob’s worth, and more under the EIP-7623 floor. At the median execution base fee of 0.048 gwei over the morning of 12 November 2026, that is about 0.0001 ETH, around 21 cents, against roughly 0.11 cent for a blob in the same hours. Blobscan, a blob explorer, runs the comparison over all history: it estimates that the blob data posted since Dencun would have cost about $1.9 billion as calldata, against about $14.9 million actually paid in blob fees (its statistics of 12 November 2026; the calldata figure is Blobscan’s own estimate).
What a blob is, field by field
4,096 field elements, 128 KiB, a beacon chain sidecar
A blob is a fixed-size piece of data: 4,096 field elements of 32 bytes each, so 131,072 bytes, exactly 128 KiB. Each element is a number in the scalar field of the BLS12-381 elliptic curve and must stay below that field’s modulus, so a rollup fits a little less than 128 KiB of its own data into one blob. A batch that falls short of a full blob still pays for the whole of it: the price is per blob, not per byte used.
Blobs do not travel inside the execution block, the part that holds accounts and smart contract state. They ride beside the beacon block as “sidecars” handled by consensus clients. In the words of the EIP-4844 specification, blob data “is simply part of the beacon chain and is fully downloaded by all consensus nodes”, a design that PeerDAS changed in December 2025. The execution layer, where the EVM runs, never sees the bytes at all.
KZG commitments and versioned hashes: what the EVM can see
What the execution layer does see is a fingerprint. For each blob, the sender computes a KZG commitment, 48 bytes on the BLS12-381 curve, that binds to the blob read as a polynomial: change one byte of the blob and the commitment no longer matches. The transaction then carries a versioned hash, made of a version byte (0x01 for KZG) followed by the last 31 bytes of the SHA-256 hash of that commitment. One of the six blobs in the Base transaction above has a versioned hash starting with 0x01756305.
The version byte is there for the future. The specification says Ethereum could one day move “to Merkle trees + STARKs for quantum-safety reasons” by adding a new version, without breaking the contracts that store these hashes. It is the same question raised by the SNARK versus STARK choice in the ZK rollups lesson: KZG relies on elliptic-curve pairings that a large quantum computer could break, while hash-based commitments are not exposed in the same way.
Type-3 transactions, BLOBHASH and the point evaluation precompile
Blobs arrive in a new transaction type, 0x03, the blob-carrying transaction. It looks like an EIP-1559 transaction with two extra fields: max_fee_per_blob_gas, the most the sender will pay per unit of blob gas, and the list of versioned hashes. Its recipient field may not be empty, so a blob transaction cannot deploy a contract.
Contracts reach blobs through two narrow doors. The BLOBHASH opcode (0x49, 3 gas) returns the versioned hash of one of the current transaction’s blobs, which lets a rollup’s inbox contract record which data a batch committed to. The point evaluation precompile, at address 0x0A and costing 50,000 gas, checks a KZG proof that the blob, read as a polynomial, takes a given value at a given point. The contents themselves are never readable by the EVM.
The two families of rollups use these doors differently, as the specification’s rationale describes. An optimistic rollup needs a few blob values only when someone disputes a batch: during a fraud proof, it loads them with KZG proofs through the precompile (see our lesson on optimistic rollups and their challenge game). A ZK rollup instead proves that the blob’s commitment and the commitment used inside its own validity proof refer to the same data, a “proof of equivalence”. Its proof then covers exactly the bytes Ethereum published.
Deleted after about 18 days, and why that is enough
Consensus clients must serve blobs for 4,096 epochs. An epoch is 32 slots of 12 seconds, so 4,096 epochs last about 18.2 days; the specification itself says “around 18 days”. After that, nodes may prune the data. The versioned hashes stay on Ethereum for good, so anyone who kept an old blob can still prove it is the original.
Eighteen days covers the challenge window of the large optimistic rollups, about 6.4 days on Arbitrum One, with a wide margin. For a ZK rollup, the state is settled as soon as Ethereum verifies the proof. The rollup’s state does not expire with its blobs either: its latest state root lives in a contract on Ethereum. What leaves Ethereum’s nodes is the raw transaction history, which then depends on the rollup’s own nodes, on explorers and on archivers; Blobscan, for one, indexes blobs and serves their contents.
| Part of a blob | Value in the specification (Final) | What it means |
|---|---|---|
| Size | 4,096 field elements x 32 bytes = 131,072 bytes (128 KiB) | Slightly less is usable, each element must stay below the curve’s modulus |
| Blob gas | 131,072 per blob | A meter separate from ordinary gas |
| Transaction type | 0x03 | Cannot create a contract (recipient required) |
| Commitment | KZG, 48 bytes, BLS12-381 curve | Binds to the whole blob |
| Versioned hash | 0x01 + last 31 bytes of SHA-256(commitment) | The only thing the EVM sees |
| EVM access | BLOBHASH opcode 0x49 (3 gas); point evaluation precompile 0x0A (50,000 gas) | Contents never readable by contracts |
| Fee | Blob base fee x blob gas, burned | Not refunded if the transaction fails |
| Retention | 4,096 epochs, about 18 days | Then consensus clients may prune it |
The KZG ceremony: 141,416 contributions and one honest participant
KZG commitments need a public structured reference string, a long list of curve points derived from a secret number. Anyone who knew that secret could forge commitments and claim a blob held data it never held. The remedy is a ceremony in which many participants, one after another, mix their own randomness into the string and then throw it away. The result is safe if at least one of them was honest and destroyed their input.
Ethereum’s ceremony ran for 208 days, from 13 January 2023 at 13:13 UTC to 8 August 2023 at 23:08 UTC, according to the Ethereum Foundation’s wrap-up of 23 January 2024. It gathered 141,416 contributions, which the foundation described as the largest setup of this kind at the time. To keep out spam, entrants had to sign in with an Ethereum address (93.36% did) or a GitHub account (6.64%).
The figure counts contributions, and the security argument does not need them all to be honest: one is enough. STARK-style commitments, built from hash functions, need no such setup, which is another reason the versioned hash keeps room for a different scheme later.
A second fee market with its own base fee
Excess blob gas and the exponential rule
Every blob uses 131,072 units of blob gas. Each block header records a running total called excess blob gas: the blob gas used above the target, carried from block to block and never below zero. The blob base fee is then about 1 wei multiplied by e raised to the power of excess blob gas divided by an update fraction. Busy blocks push the excess up and the price climbs exponentially; quiet blocks pull it down. The minimum is 1 wei.
The idea comes from EIP-1559, with one difference the specification points out: the price “responds in the same way to the same total usage regardless of how it’s distributed”. Ten full blocks followed by ten empty ones leave the price where it started, whatever the order.
The blob fee is burned, like the execution base fee, and the specification states that it is not refunded if the transaction fails. A blob transaction also pays ordinary gas for its own execution, 21,000 gas or more, at the normal base fee plus a tip. That is the “envelope” of the opening example.
| Period (from) | Target / max blobs | Update fraction | Price change after a full block | Price change after an empty block |
|---|---|---|---|---|
| Dencun, 13 Mar 2024 | 3 / 6 | 3,338,477 | +12.5% | -11.1% |
| Pectra, 7 May 2025 | 6 / 9 | 5,007,716 | +8.2% | -14.5% |
| BPO2, 7 Jan 2026 (current on 12 Nov 2026) | 14 / 21 | 11,684,671 | +8.2% | -14.5% |
The figures come from the constants of the original blob specification, EIP-7691 and the live client configuration; EIP-7691 states the +8.2% and -14.5% itself. The asymmetry since Pectra exists because the maximum is only 1.5 times the target. At 14/21, a full block puts 7 blobs above the target, while an empty block takes 14 away.
A real blob bill on 12 November 2026
Back to the Base transaction. Its receipt shows 786,432 units of blob gas used (6 x 131,072) at a blob gas price of 4,567,735 wei. Multiplied, that is about 3.59 x 10^12 wei, or 0.00000359 ETH. The execution part, 21,000 gas at an effective price of 0.3228 gwei, came to about 0.0000068 ETH. Read from a public Ethereum RPC node at about 09:45 UTC the same morning, the blob base fee stood at 4,270,424 wei, which prices one blob at about 0.00000056 ETH, roughly 0.11 US cent.
Over the 1,024 blocks from 26,397,022 to 26,398,045, about 3.4 hours to 09:45 UTC, the blob base fee moved between 2.08 and 5.49 million wei, with a median of 2.84 million. Blocks carried 5,588 blobs, 5.44 per block on average: 39% of the target of 14.
These numbers are easy to misread by a factor of a thousand. One ETH is 10^18 wei, so 131,072 blob gas at 3.6 million wei comes to about 4.7 x 10^11 wei. That is less than half a millionth of an ETH: around a tenth of a US cent per blob, not a dollar.
The first spike: blobscriptions in March 2024
The market met its first stress test two weeks after launch. On 27 March 2024, “blobscriptions”, inscriptions written into blobs through the Ethscriptions protocol, brought demand from outside the rollups. CoinDesk reported on 28 March 2024, citing a Dune Analytics dashboard, that the blob base fee soared to at least 582 gwei, about $266 per blob by its conversion, from the 1 wei floor where it had sat since launch.
The rule did what it was designed to do. Under the Dencun parameters, a run of full blocks raised the price by 12.5% per block, which compounds to a factor of about 34 over 30 blocks, six minutes. For rollups the episode was a lesson in exposure: when blob gas costs 1 wei, the data share of a layer 2 fee is close to nothing, and when demand stays above target for a while, that share can grow many times over within the hour.
From 3 to 14 blobs per block: Pectra, BPO1 and BPO2
| Date and time (UTC) | Upgrade | EIP | Target / max blobs per block | Data per block, target / max |
|---|---|---|---|---|
| 13 Mar 2024, 13:55 | Dencun | EIP-4844 | 3 / 6 | 384 KiB / 768 KiB |
| 7 May 2025 | Pectra | EIP-7691 | 6 / 9 | 768 KiB / 1.125 MiB |
| 3 Dec 2025, 21:49 | Fusaka | EIP-7594, EIP-7918, EIP-7892 | 6 / 9 (unchanged) | 768 KiB / 1.125 MiB |
| 9 Dec 2025, 14:21 | BPO1 | EIP-7892 mechanism | 10 / 15 | 1.25 MiB / 1.875 MiB |
| 7 Jan 2026, 01:01 | BPO2 | EIP-7892 mechanism | 14 / 21 | 1.75 MiB / 2.625 MiB |
Dencun activated at epoch 269,568, at 13:55 UTC on 13 March 2024, according to the Ethereum Foundation’s Dencun announcement of 27 February 2024. It shipped the blob proposal with eight other changes, among them EIP-7516, a BLOBBASEFEE opcode that lets contracts read the blob price. Pectra, on 7 May 2025, doubled the target to 6 and raised the maximum to 9 through EIP-7691.
Fusaka, live at 21:49 UTC on 3 December 2025, kept 6/9 but brought PeerDAS and the EIP-7918 reserve price, both explained below, and it put to work a new kind of upgrade. Blob-Parameter-Only forks, defined in EIP-7892, change “only blob-related parameters: target, max, and baseFeeUpdateFraction”. The Fusaka announcement scheduled two: BPO1 at 14:21 UTC on 9 December 2025 (10/15) and BPO2 at 01:01 UTC on 7 January 2026 (14/21).
The chain confirms the schedule. Asked through the eth_config method on 12 November 2026, a public node returned a target of 14, a maximum of 21 and an update fraction of 11,684,671, active since the BPO2 timestamp, with no further blob change scheduled in clients.
Demand has not kept up. In January 2025, Vitalik Buterin wrote in a post on scaling Ethereum’s L1 and L2s that “our blob space is barely covering the L2s and the usecases of today”. On the morning of 12 November 2026, blocks used 39% of the target. The scarcity of early 2025 has turned into spare room, at least for now, and spare room pushes an exponential price toward its floor.
EIP-7918: a reserve price tied to execution gas
That floor was 1 wei, and it was a problem. When usage stays under target, excess blob gas falls to zero and the price stops signalling anything. The authors of EIP-7918 described it directly: the old mechanism can keep “lowering the blob base fee until it eventually settles at 1 wei”. At that price, rollups paid nothing for the work blobs impose on nodes, and the EIP notes that verifying KZG proofs “is computationally expensive”.
The fix shipped in Fusaka. EIP-7918 defines a constant, BLOB_BASE_COST, of 8,192 (2 to the 13th). When 8,192 times the execution base fee is worth more than a blob at the current blob base fee (131,072 times that fee), the protocol stops subtracting the target from the excess blob gas, so the excess and the price climb back. In practice, the price of a unit of blob gas is held near at least one sixteenth of the execution base fee. It is a reserve, not a hard floor: the blob base fee can dip below it, and the rule then pushes it back up.
On the morning of 12 November 2026, this rule set the price. With a median execution base fee of 0.048 gwei, the reserve came to about 3.0 million wei per unit of blob gas. In 853 of 1,023 consecutive blocks, the blob base fee sat below that reserve, so the reserve clause, not blob demand, was doing the pushing. With usage at 39% of target, the old rule would have let the price drift toward 1 wei. Blob prices now follow ordinary gas: when Ethereum’s execution base fee rises, so does the level under blobs.
For a layer 2 user the change is invisible. At about a tenth of a cent per blob, and with a couple of thousand compressed transfers per blob, as the illustration in our layer 2 lesson assumes, the data cost per transfer is around five hundred-thousandths of a cent.
Did layer 2 fees really fall? Dated numbers
They did, and mostly in one step. growthepie, an Ethereum data site, takes the median transaction cost of each layer 2 per month, then the median across chains, each chain counted once and all transaction types included. Its series, as published on 12 November 2026:
| Month | Context | Cross-L2 median fee | Change |
|---|---|---|---|
| Feb 2024 | Before Dencun | 20 cents | |
| Apr 2024 | After Dencun | 1.9 cents | 10.7x cheaper |
| Apr 2025 | Before Pectra | 0.16 cent | |
| Jun 2025 | After Pectra | 0.11 cent | 1.42x cheaper |
| Nov 2025 | Before Fusaka | 0.11 cent | |
| Jan 2026 | After Fusaka | 0.10 cent | 1.09x cheaper |
| Oct 2025 | One year before | 0.13 cent | |
| Oct 2026 | Latest full month | 0.17 cent | 1.3x dearer than Oct 2025 (+30.6%) |
Dencun did the heavy lifting: from 20 cents to 1.9 cents within two months, and growthepie puts the fall since February 2024 at 118 times. Later capacity barely moved the median, 1.42 times around Pectra and 1.09 times around Fusaka, because by then blob data was no longer the main cost. What remains is execution on the layer 2 itself, the operator’s margin and the ordinary Ethereum gas paid to post batches and proofs. The median of October 2026, 0.17 cent, was higher than a year earlier, even with more than twice the blob capacity.
The first day was sharper still. The Block reported on 14 March 2024, citing a Dune dashboard, that the median fee on Base fell from around $0.5 on 13 March to about $0.0012, and that the average swap on Starknet fell from over $6.8 to $0.04, per the wallet maker Argent. Arbitrum One had not yet integrated Dencun on publication day; its ArbOS upgrade was planned for later that day.
Fees today, from growthepie’s daily median transaction cost:
| Chain | Median fee, 10 Nov 2026 | Median fee, 11 Nov 2026 |
|---|---|---|
| Ethereum (layer 1) | $0.0298 | $0.0253 |
| Linea | $0.0167 | $0.0153 |
| Arbitrum One | $0.0048 | $0.0044 |
| Starknet | $0.0037 | $0.0031 |
| Scroll | $0.0022 | $0.0016 |
| Base | $0.0018 | $0.0017 |
| OP Mainnet | $0.000025 | $0.000015 |
The gap with Ethereum itself has narrowed, because the main chain’s fees fell too. On 11 November 2026, Ethereum’s median of about 2.5 cents was 6 times Arbitrum One’s and 15 times Base’s, and less than twice Linea’s. The two layers are set side by side in our guide to layer 1 vs layer 2.
Who fills the blobs: Base, World Chain, Arbitrum and Robinhood Chain
Blobscan’s all-time statistics, updated at 09:45 UTC on 12 November 2026, count 25,219,392 blobs in 9,982,067 blob transactions since Dencun, with 4,747.3 ETH paid in blob fees, about $14.92 million at the price of each transaction. Blobs that Blobscan attributes to rollups make up 95.0% of the total; the remaining 5.0% are labelled “other”.
| Rollup (Blobscan label) | Blobs, 13 Mar 2024 to 12 Nov 2026 | Share of all blobs |
|---|---|---|
| Base | 9,108,755 | 36.1% |
| World Chain | 2,869,066 | 11.4% |
| Arbitrum | 2,418,953 | 9.6% |
| OP Mainnet | 1,561,232 | 6.2% |
| Taiko | 1,208,743 | 4.8% |
| Robinhood Chain | 1,157,381 | 4.6% |
| Soneium | 564,472 | 2.2% |
| Unichain | 468,375 | 1.9% |
Base alone has paid 1,693.5 ETH in blob fees since launch, about $5.29 million by Blobscan’s count. Divide all fees by all blobs and the average comes to about $0.59 per blob, against roughly a tenth of a cent on 12 November 2026: the all-time average is dominated by expensive stretches such as March 2024, not by the quiet market of today.
The recent picture differs. Over the 30 days from 12 October to 10 November 2026, among the chains growthepie tracks, Base posted 34.3% of blob bytes, Robinhood Chain 21.5%, MegaETH 11.2%, OP Mainnet 8.9%, Celo 8.4%, Arbitrum 5.8% and World Chain 4.1%. growthepie covers a subset of chains and Blobscan labels its own, so the two sets of shares do not add up to the same thing.
Not every layer 2 uses blobs. According to the API of ETHBEAT, formerly L2BEAT, on 12 November 2026, 39 of 80 active layer 2s post their data to Ethereum as blobs, and they hold $30.9 billion of the $35.9 billion those 80 secure, 86.1%. Of the others, 14 use a custom data availability solution, 9 a data availability committee, 7 Celestia, 5 EigenDA from the EigenLayer family, 2 EigenDA with a verifier contract, and 3 still post calldata. Chains that keep data off Ethereum are validiums or optimiums rather than rollups in the strict sense, as the ZK rollups lesson explains. ETHBEAT’s custom group includes Polygon PoS, which it files under “Others”, a case for the next lesson of this path, on sidechains versus rollups.
PeerDAS: checking blob data without downloading all of it
Why blockchains need scaling sketched data availability and summed up PeerDAS in one sentence: nodes download parts and sample the rest. Here is how the parts are cut. Before Fusaka, every consensus node downloaded every blob, which was manageable at Pectra’s maximum of 1.125 MiB per block and would be heavy at today’s 2.625 MiB. EIP-7594, live since 3 December 2025, removed that requirement.
The first step is erasure coding. Each blob’s 4,096 field elements are extended with a Reed-Solomon code to 8,192, twice the original size, so the original can be rebuilt from any half. The extended blob is cut into 128 cells of 64 field elements. Picture the blobs of a block stacked as rows: the cells at the same position in every row form a column, and there are 128 columns, each with its own gossip channel on the peer-to-peer network.
The second step is custody. Each node keeps at least 4 column groups out of 128. A node running validators keeps one group for each 32 ETH of their combined effective balance, never fewer than 8 and at most all 128. On top of that, each node samples at least 8 columns per slot from its peers. Columns are kept for 4,096 epochs, like blobs. A node with a large validator balance therefore holds many more column groups than a plain full node.
Sampling works because of a property the specification states plainly: “A node can reconstruct the entire data matrix if it acquires at least 50% of all the columns.” To make a blob unrecoverable, a block producer would have to withhold more than half of the columns. A node whose random samples cannot be fetched treats the block as unavailable and does not follow it. With the current parameters, the EIP says a node downloads about one eighth of the data, a share it expects could fall to 1/16 or 1/32 later.
The EIP explains why it chose columns rather than rows: extensions can be computed before a block exists, off the critical path, and most nodes already hold most blobs from the public mempool. The heavy work moved to the senders. Computing the proofs for each cell is costly, so since Fusaka the blob transaction’s sender, the rollup, computes them and ships them in a new mempool wrapper. Rollup batchers had to update their software before the upgrade.
The load on nodes is also the second argument behind EIP-7918. Its rationale counts the work of a full node, which verifies all blobs in the execution mempool, samples 8 columns and custodies 4. That work is why a blob should not cost 1 wei, and it is the cost a home operator weighs when running one of the machines described in our guide to what a node does.
PeerDAS has limits. It samples in one dimension, columns of the matrix, and each column still spans every blob of the block. Full data availability sampling, in two dimensions with many more columns, remains future work.
Full Danksharding and Glamsterdam: plans, not promises
The blob proposal listed in 2022 what full sharding would still need: “A low-degree extension of the commitments in the consensus layer to allow 2D sampling”, a real implementation of data availability sampling, proposer-builder separation so that individual validators do not have to process 32 MB of data in one slot, and proof of custody. PeerDAS delivered a one-dimensional version of sampling. The rest was not live on mainnet as of 12 November 2026.
The ethereum.org page on danksharding, updated on 22 October 2026, still says “Full Danksharding is several years away” and presents 64 blobs per block and more than 100,000 transactions per second as aims of the design. The same page still gives six blobs for proto-danksharding, while the live target has been 14 since January 2026. Vitalik Buterin’s January 2025 post set a similar aim: “When we get to 2D sampling, we can reach 128 blobs per slot.” Both are goals of researchers, not dates.
The next upgrade, Glamsterdam, has run on the Sepolia test network since 6 October 2026. Its meta specification, EIP-7773, still showed a Hoodi testnet activation for 26 October 2026 on 12 November 2026, but that fork was postponed without a new date, and a public Hoodi node queried that day had no Glamsterdam activation configured. Mainnet had no date either. Three of its changes touch blobs. EIP-7732, enshrined proposer-builder separation, gives more time for “data availability checks” and lets the builder broadcast blob column sidecars early. EIP-7976 raises the calldata floor to 64 gas per byte, and its text lists “Better blob incentivization” among the reasons. EIP-8070, the sparse blobpool, has execution nodes fetch full blobs only with a probability of 0.15 and sample the rest, because the EIP expects mempool blob traffic to dominate bandwidth as BPO forks raise throughput. No new BPO fork was configured in clients on 12 November 2026.
“L2s don’t pay”: the argument over blob revenue
The numbers behind the complaint are stark. Over the 30 days to 10 November 2026, the layer 2s tracked by growthepie paid about $8,589 in blob fees (Base $3,577, Robinhood Chain $1,924, Arbitrum $1,287) and about $84,700 in all costs on Ethereum, blobs plus the ordinary gas for posting batches and proofs. In the same 30 days, Base users paid about $2.63 million in fees, Robinhood Chain users about $1.29 million and Arbitrum users about $0.55 million. growthepie puts Base’s margin, user fees minus Ethereum costs, at about $2.61 million.
The burn tells the same story. Over the 1,024 blocks of the morning of 12 November 2026, blobs burned about 0.0022 ETH while the execution base fee burned about 1.65 ETH, so blobs were roughly 0.14% of the ETH burned (an estimate: the execution burn is derived from each block’s gas used and the 60 million gas limit). Since Dencun, Blobscan counts 4,747 ETH burned through blob fees in total.
Vitalik Buterin framed the concern himself in January 2025: “We need to make sure that ETH continues to accrue value even in an L2-heavy world.” Among the ideas he listed were layer 2s “burning a portion of fees, permanently staking them”, and on Ethereum’s side, to “consider a minimum blob price”. To show the stakes, he took the average blob fee of the previous 30 days and multiplied by 128 blobs per slot: the result would burn “713,000 ETH per year”, an illustration he hedged with “such a favorable demand curve is not guaranteed”.
The defence starts with the design. EIP-4844 was written to make rollup data cheap, not to raise revenue, and a price near its floor means capacity is spare. Layer 2s also pay Ethereum outside blobs: the ordinary gas of each batch posting, which in the opening example cost about twice the six blobs together, plus proof verification for ZK rollups; most of them use ETH as their gas token. And the minimum blob price Vitalik Buterin floated now exists in a form: since Fusaka, EIP-7918 ties blob prices to execution gas.
Neither side has a number that settles it. Revenue from blobs depends on demand for layer 2 block space, which pressed against the target in early 2025, by Vitalik Buterin’s account, and now sits under it, and on the execution base fee that the reserve price follows. Whether that trade suits ETH holders is a question about the future of demand, and this lesson takes no view on the price of ETH.
What blobs change for you, and for your tax return
A layer 2 fee has two parts: execution on the layer 2 and a share of the cost of posting the batch to Ethereum. Since Dencun, the blob part is often the smallest piece, and you never pay it directly: the rollup pays Ethereum and folds the cost into your fee. A blob surge such as the one of March 2024 can raise layer 2 fees for a while, because that share follows the blob base fee.
Blobs do not set withdrawal times. A withdrawal from a layer 2 to Ethereum waits for the challenge window of an optimistic rollup or for the proof of a ZK rollup, as the two previous lessons explain. The 18-day life of a blob only matters for history: old layer 2 transactions stay visible through the rollup’s own explorers and through blob archives, not through Ethereum nodes.
You can see blobs yourself. On Etherscan, a type-3 transaction shows its blob gas used, its blob gas price and its list of versioned hashes; Blobscan shows the blobs of a block, their size, the fee paid and the rollup that sent them, and serves their contents while it keeps them.
For taxes, blob fees reach you only inside the layer 2 fee. In the United States, the Treasury regulation on digital asset sales, 26 CFR 1.1001-7, reduces the amount realized on a sale by the “digital asset transaction costs” allocable to it, and treats digital assets used to pay those costs as disposed of for services: a fee paid in ETH is itself a small disposal for the IRS. In the United Kingdom, HMRC’s cryptoassets manual (CRYPTO22150, updated 28 November 2025) counts “transaction fees paid for having the transaction included on the distributed ledger” among allowable costs for Capital Gains Tax. Neither text mentions blobs; a tax adviser can say how they apply to your own records.
The next date to watch is Glamsterdam’s mainnet activation, still unset on 12 November 2026, along with any new BPO fork that raises the blob target again. The next lesson of this path compares sidechains and rollups, starting with the chains that never posted blobs at all.
