EIP-8266 Expiring nonces for frame transactions
No call decision · Account abstraction · EIP status Draft · created 2026-05-15
Adds an expiring-nonce mode to EIP-8141 frame transactions. Instead of the account nonce, a short deadline prevents replay, and once the deadline passes the record slot is cleared and reused, so state does not grow permanently.
Why it is needed
Ethereum today prevents a transaction from being executed twice using the nonce, a number that increments once per account. EIP-8141's frame transactions use this same approach. But for transactions that become meaningless if not processed within seconds, such as atomic intent transfers or time-bound fee sponsorship, this approach is overly strict. Because the number enforces ordering, the sender must decide the order in advance, it is hard to queue several transactions at once, and the order in which they land in a block is tied to the nonce order, even though the only real risk to guard against is replay within the short window before the deadline. This EIP adds an expiring nonce, whose protection ends once the deadline passes, freeing short-lived transactions from nonce ordering. The record space is bounded in a fixed-size ring buffer, so state does not accumulate no matter how many transactions occur.
What changes
Today
- Frame transactions are also processed strictly in account nonce order
- A single account has trouble queuing several transactions at once
- Even a short-lived, throwaway transaction leaves a permanent nonce-increment record
After EIP-8266
- Setting the nonce field to a special value switches to deadline-based protection
- A single account can send multiple expiring transactions at once
- Records are kept in a fixed-size ring buffer, keeping total state size constant
Who is affected
- Wallet & app developers: Short-lived transactions such as atomic intents or time-bound fee sponsorship can be designed without worrying about nonce ordering. However, validators that assumed TXPARAM(0x01) was the account nonce must be fixed to reject expiring transactions or to handle the sentinel.
- Users: Multiple expiring transactions and a regular nonce transaction can be queued on the same account at the same time.
- Client teams: NONCE_RING must be installed, along with state-based validity checks, mempool rules that re-evaluate on every new head, and payer balance reservation accounting.
- Single-use applications: Approaches that derived intent from the legacy nonce lose their ordering guarantee, so the pre-state nonce must now be explicitly authenticated.
In depth
Turning on the mode with a sentinel
If tx.nonce == EXPIRING_NONCE_SENTINEL(2**64 - 1), it is expiring-nonce mode; otherwise the transaction behaves exactly as in EIP-8141. In this mode, the protocol neither reads nor writes state[tx.sender].nonce for replay-protection purposes. Instead of adding a new flag field to the envelope, it reuses a value that already falls within the existing nonce field's range (under 2**64) as the sentinel, so there is no payload schema change, and the standard signing hash commits to the mode indication together via the existing nonce field. The deadline is likewise authenticated by the sender not through a new field but by reusing the expiry_verify frame that EIP-8141 already defines (the standard contract, 8-byte big-endian calldata, signing hash exception).
NONCE_RING storage structure
Three slot families are placed at the system address NONCE_RING (value TBD). slot_seen(h) = keccak256(h || left_pad_32(0)) stores the deadline (uint64, 0 means none) of signing hash h; slot_ring(i) = keccak256(left_pad_32(1)) + i stores the signing hash (bytes32, 0 means none) of the i-th ring slot; slot_ring_ptr = left_pad_32(2) stores a monotonically increasing counter. i ranges over [0, RING_CAPACITY), and RING_CAPACITY is 262144 (2**18). The installed code NONCE_RING_CODE (0x60006000fd) is equivalent to revert(0, 0), so any ordinary call reverts with empty return data. The address must be chosen so that, at fork-configuration time, it has neither code nor storage on every target network.
Stateful validity checks
There must be exactly one frame with mode == VERIFY and target == EXPIRY_VERIFIER, and its data must be read as an 8-byte big-endian deadline d satisfying now <= d <= now + MAX_EXPIRY_SECS (60 seconds). Additionally, the value stored at slot_seen(h) must be less than now. The strict inequality (<) is necessary to prevent reuse within the same block when d == block.timestamp. In this mode, EIP-8141's sender nonce check (tx.nonce == state[tx.sender].nonce) is skipped.
Nonce consumption and BufferFull
In the sole successful payment scope APPROVE, consume_expiring_nonce executes exactly once per transaction, atomically. If the position ptr % RING_CAPACITY already holds a hash whose deadline is still at or after now, BufferFull occurs, APPROVE aborts, payer is not set, and the transaction is invalid under EIP-8141. If the entry has expired, its slot_seen is cleared to 0, the new hash and deadline are written, and the pointer is incremented by 1. This effect is recorded as an EIP-8141 approval effect outside the current frame's revert journal and the SENDER atomic batch snapshot, and must not be undone by a later frame revert or batch rollback. As long as the sizing invariant holds, BufferFull is unreachable, but it is kept as a safeguard so that a momentary load spike or a miscalculated future fork fails the approval instead of silently weakening replay protection.
Gas of 13000 and protocol bookkeeping
In expiring mode, the payment-scope APPROVE deducts an additional EXPIRING_NONCE_GAS = 13000 after EIP-8141's normal checks and opcode costs, before the approval effect is committed. If the remaining gas is less than that, it aborts with out-of-gas and there is no approval effect. The reads and writes of validity checking and consume_expiring_nonce are protocol bookkeeping, so they are not added to EIP-2929's accessed_addresses or accessed_storage_keys, EIP-2200 SSTORE pricing does not apply, and they do not make any address or slot warm. The 13000 figure excludes the SSTORE_SET surcharge for writing from 0 to non-0, because every new slot_seen write is paired, within the same transition, with clearing to 0 the slot_seen of an entry leaving the ring, so under normal operation the number of leaves in the storage trie is invariant. The total size is fixed at exactly 2 x RING_CAPACITY slots regardless of usage, and the one-time cost of first filling the ring is not charged to transactions but absorbed by the protocol.
The relationship between ring size and replay security
Safety depends on the invariant MAX_EXPIRY_SECS x peak_tps <= RING_CAPACITY. With MAX_EXPIRY_SECS = 60 (5 Ethereum slots) and RING_CAPACITY = 2**18, expiring transactions sustained at up to about 4369 TPS will not cause a still-live deadline to be evicted. If deadlines had no upper bound, an attacker could pin a single slot far into the future, and once the ring wrapped past that point a live entry could be evicted, opening a replay window. The replay window is bounded by the deadline d. Resubmission after d is rejected by the expiry_verify frame, and resubmission before d is rejected by the seen check.
Mempool rules and activation procedure
Nodes must reject an expiring transaction if any of its stateful validity assertions fails, and must re-evaluate on every new head, evicting transactions that no longer pass. EIP-8141's one-pending-per-sender guideline does not apply, so multiple such transactions can be accepted, but a new transaction should only be accepted if the gas payer's available balance can cover it, applying reserved_pending_cost accounting that reserves each pending transaction's max_fee against that balance. Activation must be at or after EIP-8141's, and on the first execution payload at or after FORK_TIMESTAMP, NONCE_RING_CODE is installed with nonce 1 and empty storage before transaction execution, preserving any existing balance. Frame transactions and authorizations bound to the pre-fork standard signing hash cannot cross the boundary and must be evicted from the mempool and recreated.
Remaining caveats and status
Because expiring transactions do not increment the account nonce, a single EOA can have several expiring transactions and a separate ordinary-nonce transaction pending at the same time. Single-use applications that derive intent from the legacy nonce should not rely on transaction ordering and should instead explicitly authenticate the pre-state legacy nonce. NONCE_RING's storage is system-managed; ordinary direct calls revert, and any balance sent to this address is not recovered by this EIP's protocol logic. A composition is presented, non-normative, for deployment alongside EIP-8250 in which the sentinel is absorbed into the reserved key nonce_key == 2**256 - 1. This EIP is in Draft status, so its content may still change, and the provided call records contain no fork-inclusion decision.