EIP-8256 Blob streaming
No call decision · Scaling & data · EIP status Draft · created 2026-05-06
Introduces AOT blobs, which, instead of sending blob data together with block propagation, let a user buy a ticket in advance and propagate the data ahead of time over the consensus layer network. The existing approach remains as JIT blobs, and the two channels share a single blob base fee.
Why it is needed
Today, blob data must propagate together with the block within the short window during which the block spreads across the network. The amount that can be processed on this critical path is limited, making it hard to raise blob throughput. Extending the propagation window would worsen the free-option problem, where a builder can watch market conditions during that time and invalidate the block if conditions turn unfavorable. Pre-propagating data through an execution layer blob pool is another option, but since there is no cap on the processing load, different nodes could end up seeing different data, and combined with data availability sampling (DAS) this becomes vulnerable to denial-of-service (DoS) attacks. This proposal solves the problem by requiring a ticket to be purchased in advance to gain propagation eligibility. The set of parties eligible to propagate is restricted to a globally agreed, finite set, and since both honest users and attackers must pay the same network resource cost upfront, the scheme is resistant to DoS. The propagation time can also be chosen flexibly within a fixed time window, reducing congestion and substantially raising overall throughput without extending the block propagation window.
What changes
Today
- Blob data must propagate together with the block within its short propagation window
- It can be pre-sent through an execution layer blob pool, but with no cap on load, nodes may see different data, leaving it vulnerable to DoS
- The blob fee is calculated from the excess_blob_gas and blob_gas_used fields in the block header
- Blob sidecars propagate through the execution layer mempool
After EIP-8256
- A user who has bought a ticket propagates blob data over the consensus layer subnet ahead of the target slot (AOT)
- For use cases that need to finalize data at the last moment, the existing approach remains available as JIT blobs
- Fee state moves to the ticket contract, and the two channels share a single blob base fee
- The execution layer mempool carries only the transaction body without blob data, and propagation eligibility is tied to holding a ticket
Who is affected
- L2s and rollups: Sequencers that send batch data in advance can use the AOT channel, while those that finalize batch contents right before the inclusion deadline continue to use the JIT channel.
- Client teams: The block header format, mempool, Engine API, and gossip subnets all change, so every execution layer and consensus layer client must be updated.
- Wallet & app developers: Tools that computed the blob fee from header fields must switch to querying the ticket contract or using the BLOBBASEFEE opcode. Existing contracts that use BLOBHASH and BLOBBASEFEE continue to work unchanged.
- Builders / validators: Ticketless JIT blob data is delivered directly to the builder instead of through the public mempool, and the builder includes only transactions whose AOT commitments already have their data secured.
In depth
Classification of blob transactions into JIT and AOT
Blob transactions (type 3) are classified by their max_fee_per_blob_gas value. If it is at or above the current blob base fee, the transaction is JIT: the fee is paid at inclusion time and the data is propagated at block time. If it is 0, the transaction is AOT: no blob fee is paid at inclusion time, but it must be backed by a valid ticket, and the data is propagated ahead of time at the consensus layer. Any value from 1 up to blob_base_fee - 1 is invalid and must be rejected. A single transaction must be entirely JIT or entirely AOT. AOT transactions are signed with max_fee_per_blob_gas == 0, so a builder cannot reclassify one as JIT, because the execution layer rejects as JIT any transaction whose value is below the current fee. Whether AOT reuses type 3 or uses a new transaction type without a blob fee field is a design decision left open for now, and the two approaches are mechanically equivalent.
Removing header fields and moving fee state
The block header fields excess_blob_gas and blob_gas_used, introduced by EIP-4844, are removed. All blob base fee state is managed inside the ticket contract, and clients read the fee from the contract at the start of block processing and cache it for the duration of block processing. The BLOBBASEFEE (0x4A) opcode still returns the blob base fee, but its source changes from a header-field computation to a contract state read cached at the start of the block; BLOBHASH (0x49) is unchanged. Existing contracts work without modification, but contracts and tools that computed the fee directly from the header field must be changed to read the ticket contract or use BLOBBASEFEE instead. The header RLP encoding changes, so every execution layer client must be updated.
The ticket contract and ring buffer storage
The ticket contract is a system contract deployed at TICKET_CONTRACT_ADDRESS, the same approach used by EIP-4788 and EIP-7002, and it has three code paths. A call with value is a ticket purchase: it takes (blob_count, bls_pubkey), requires payment of at least blob_count * GAS_PER_BLOB * fee, and sends the payment to ZERO_ADDRESS to burn it. There are no refunds, which is the primary defense against capacity preemption attacks. A call with no value and no calldata returns the current fee, and at the end of the block SYSTEM_ADDRESS executes a system call. Tickets are stored in a ring buffer of per-slot buckets whose ring length equals TICKET_LOOKAHEAD. A ticket bought at slot s targets slot s + TICKET_LOOKAHEAD, and the bucket is reused once that slot comes back around, so tickets expire naturally with no explicit cleanup. The total AOT reservation for a single slot cannot exceed MAX_AOT_BLOBS_PER_BLOCK (B2 - R). A ticket record stores ticket_id, the sale block timestamp, the owner address, blob_count, and the BLS public key across 5 storage slots.
A single fee mechanism and the EIP-7918 reserve price
The end-of-block system call takes jit_blob_gas_used as input, sums the JIT blob gas used with the AOT ticket sales volume (TICKET_COUNT_SLOT * GAS_PER_BLOB) to update the excess blob gas accumulator, and computes the next block's fee with fake_exponential(MIN_BLOB_BASE_FEE, new_excess, BLOB_BASE_FEE_UPDATE_FRACTION). fake_exponential is the same function as in EIP-4844. EIP-7918's reserve price logic is also implemented here: if BLOB_BASE_COST(8192) * the execution base fee is greater than GAS_PER_BLOB(131072) * the current blob fee, only a proportional amount is subtracted from the accumulator instead of the full TARGET_BLOB_GAS, preventing the fee from falling further. Keeping separate fees for JIT and AOT would create an inefficient dual market where demand shifts to whichever channel is cheaper, so a single fee symmetrically reflects total demand across both channels. Both the JIT fee and the AOT ticket payment are burned.
Execution layer mempool: removing sidecars and blob allowance
Blob sidecars (blob data, KZG commitments, and proofs) are no longer propagated in the execution layer mempool; the mempool now only carries transaction bodies with the blob data stripped out. Mempool propagation of blob transactions is tied to holding a ticket. The blob allowance for address S is the sum of blob_count across S's active tickets minus the number of blobs in S's blob transactions already in the mempool, and a node SHOULD only accept and relay a transaction when the allowance is sufficient. This condition applies regardless of JIT or AOT, so blob transactions from addresses without a ticket cannot propagate through the public mempool, and ticketless JIT transactions are delivered directly to builders outside the protocol. Replacement transactions are possible with a valid ticket, but only a limited number of times, and a replacement that changes the versioned hash requires re-propagating that blob data, which may require a different ticket.
Consensus layer changes: bid separation and the AOT gossip subnet
In ePBS's (EIP-7732) ExecutionPayloadBid, the existing blob_kzg_commitments field is split into two. jit_blob_kzg_commitments is needed for propagation on the critical path before payload disclosure, so it is included in the bid as a full list, while aot_blob_kzg_commitments_root only holds the hash_tree_root of the AOT commitment list. The full list is provided as aot_blob_kzg_commitments in the ExecutionPayloadEnvelope to verify the root matches. A new gossip subnet, aot_data_column_sidecar_{subnet_id}, and the AotDataColumnSidecar container are introduced for AOT data. Validation rules require that the target slot be within [current_slot, current_slot + AOT_PROPAGATION_WINDOW_SLOTS], that the ticket ID be valid, that the BLS signature from the public key registered to the ticket and the KZG proof be valid, and that only the first valid sidecar be accepted per (ticket_id, column_index). JIT and AOT share the same custody model using the same column indices, and the is_data_available check combines both into a single boolean used for PTC attestations.
Engine API changes
An activeTickets array is added to the engine_forkchoiceUpdatedV5 response. Each TicketInfoV1 contains ticketId, sellingBlockTimestamp, owner, blsPubkey, and blobCount; the consensus layer uses the BLS public key for AOT gossip validation and the execution layer uses the owner address to control mempool propagation. PayloadAttributesV5 adds availableAotBlobCommitments, through which the consensus layer passes the list of commitments it has secured pre-propagated data for, and builders SHOULD only include AOT transactions on that list. engine_newPayloadV6 takes two lists, expectedJitBlobVersionedHashes and expectedAotBlobVersionedHashes, for validation. engine_getPayloadV7's blobsBundle only carries JIT data, and a new aotBlobInfo field carries the versioned hash, KZG commitment, and ticket ID of AOT blobs. engine_getBlobsV3 returns null for AOT hash lookups, since the execution layer does not hold AOT data.
Security considerations and status
A capacity preemption attack that buys tickets without propagating the data is deterred because the refund-free fee burn makes its cost equal to that of normal usage, and transactions whose tickets have no data are not included by builders, so that capacity reverts to the JIT pool up to the overall cap B2. The source notes a possible future addition of a refundable deposit that is returned on ticket use. Because ticket sales and JIT usage move the fee together, manipulating only one channel is more costly than manipulating a unified fee. Having JIT blobs delivered directly to builders increases the builder's gatekeeping role, but this reflects the existing flow under ePBS, and the AOT channel mitigates it. This proposal includes no mechanism to force inclusion of AOT transactions; a design using FOCIL (EIP-7805) inclusion lists and PTC availability voting is left as future work. Since a reorg can change ticket state and fees, nodes must refresh their ticket cache from forkchoiceUpdated responses. This EIP is currently in Draft status, and several constants, including the contract address, capacity limits (B1, B2, R), and TICKET_LOOKAHEAD, are still TBD, so the contents may still change.