EIP-8202 Signature-scheme-selectable transactions (Scheme-Agile Transactions)

No call decision · EVM & execution · EIP status Draft · created 2026-03-22

Creates a common transaction type 0x05 that attaches features like blobs or set-code as extensions rather than as new transaction types, and that lets the signature scheme be chosen as well. It also defines a post-quantum signature scheme that uses each key only once.

Why it is needed

Until now, Ethereum has added a new transaction type every time a new feature appeared, such as blobs or set-code delegation. Although the contents of most of these types are little more than the EIP-1559 shape with a few fields appended, combining features requires a new type for each combination. For example, a user who wants to combine passkey signatures with blob and set-code authorization at once would need yet another top-level type created for them. The signature scheme is also a problem. Today's externally owned accounts (EOAs) are locked into a single secp256k1 ECDSA signature, which will be broken once quantum computers advance far enough. This EIP proposes a common envelope that unifies the fee header and execution content, while attaching features like blobs or set-code as extensions and making the signature scheme a swappable scheme. It also defines a signature scheme that achieves quantum safety by using each key only once, without new cryptography, opening a path for EOAs to move to post-quantum signatures without wrapping execution in a different abstraction.

What changes

Today

After EIP-8202

Who is affected

In depth

Transaction envelope and basic rules

SchemedTransaction is serialized as 0x05 || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, data, authorizations, extensions]). The first 8 fields form the base transaction, and if to is null it is a contract creation. The base type has no access_list. The Rationale states that block-level access lists (EIP-7928) have replaced that role, and that fields on a deprecation path, such as those whose cost EIP-7981 raises, were not carried over. authorizations is an ordered list of [role_id, scheme_id, witness] entries whose order itself is part of the signature, and there must be exactly one ROLE_SENDER (0x00). ROLE_PAYER (0x01) is reserved only and must not appear in this version. extensions is a list of [extension_id, extension_payload] entries, extension_id must not be duplicated, and any unknown role_id, scheme_id, or extension_id must be rejected as invalid. The receipt payload is rlp([status, cumulative_transaction_gas_used, logs_bloom, logs]), identical to EIP-1559, EIP-4844, and EIP-7702.

Computing the signing hash

The sender signs the entire base transaction and all extensions. signing_hash(tx, auth_index) includes the witness for authorizations preceding auth_index, keeps only [role_id, scheme_id] for the current and all later authorizations, and then computes keccak256(SCHEMED_TX_TYPE || rlp([...])). Since a valid transaction in this version has only a single top-level authorization, the sender, this is in effect equivalent to signing the entire transaction minus the witness. That is, sender_signing_hash(tx) is computed by placing only [[ROLE_SENDER, tx.authorizations[0].scheme_id]] in the authorization slot. Since all extension payloads are included in this hash, the sender's signature finalizes the extensions as a whole.

Two signature schemes

The witness for SCHEME_SECP256K1 (0x00) is rlp([y_parity, r, s]), and s must be at most secp256k1n / 2 per EIP-2. The address is derived the same way as today, keccak256(pubkey)[12:], so existing EOAs can use the new format without changing address, and the scheme surcharge is 0. SCHEME_EPHEMERAL_K1 (0x01) derives 2^EPHEMERAL_TREE_DEPTH (depth 20) key pairs from a seed via a BIP 44 path, builds a binary Keccak-256 Merkle tree whose leaves are the keccak256 hash of each public key, and uses keccak256(SCHEME_EPHEMERAL_K1 || merkle_root)[12:] as the address. The witness is rlp([y_parity, r, s, merkle_root, merkle_proof]), and the Merkle proof is EPHEMERAL_PROOF_LEN = 640 bytes (20 x 32). Validation checks that the root matches the sender address, that the hash of the public key recovered via ecrecover is the leaf at position tx.nonce, that the Merkle proof is correct, and that the s-value condition is satisfied. No on-chain registration, storage write, or contract deployment is needed at all, and the account nonce the protocol already enforces serves as the Merkle leaf index. The scheme surcharge is 5,000.

Why the ephemeral key scheme is quantum-resistant, and its limits

Once the transaction at nonce i is processed, an attacker can recover pk_i from the signature, and a quantum computer running Shor's algorithm can obtain sk_i from pk_i. However, the next valid transaction requires nonce i+1, and that leaf's pk_{i+1} sits behind a keccak256(pk_{i+1}) hash. Finding it requires a Keccak-256 preimage attack. Grover's algorithm only quadratically speeds up brute force, and Keccak-256 retains 128-bit security against preimage attacks, making this computationally infeasible. The security assumption thus shifts from the hardness of the discrete logarithm problem to Keccak-256 preimage resistance. It is also explicitly noted that, while a transaction waits in the mempool, the current public key pk_i is visible in the witness, so an attacker able to run Shor's algorithm within block time could submit a competing transaction with the same nonce. The source states that this requirement far exceeds near-term quantum capability, and that private mempools and L2s with short inclusion delay mitigate it. A depth-20 tree supports roughly 1,048,576 transactions, and as exhaustion nears, funds can be moved to a new account with a new seed, or to a post-quantum scheme. Existing secp256k1 addresses whose public key has already been exposed remain at risk if ECDSA is broken, so preemptive migration is recommended.

Blob extension and set-code extension

The payload of EXT_BLOB (0x01) is rlp([max_fee_per_blob_gas, blob_versioned_hashes]). This simply moves the transaction-local fields of an EIP-4844 blob transaction into an extension; the sidecar format, the blob fee lane, and block-level blob accounting remain exactly as in EIP-4844. When this extension is present, to must not be null and blob_versioned_hashes must not be empty. The payload of EXT_SET_CODE (0x02) is rlp([authorization_list]), where each entry is [chain_id, delegate_address, nonce, scheme_id, witness]. It differs from EIP-7702 in three ways: (y_parity, r, s) is replaced by (scheme_id, witness), allowing authorizations within the same transaction to use different schemes; the authorization message hash is keccak256(SET_CODE_AUTH_MAGIC || rlp([chain_id, delegate_address, nonce, scheme_id])), which includes scheme_id; and the base envelope has no access_list, so there is no corresponding fixed gas share. The remaining processing rules, gas constants, and refunds are the same as EIP-7702, and as in EIP-7702, a set-code authorization that has been processed is not rolled back even if the execution phase fails.

Intrinsic gas calculation

intrinsic_gas = TX_BASE_COST + calldata_gas(data) + sender_scheme_gas_surcharge + extension_intrinsic_gas. TX_BASE_COST is the base cost decomposed by EIP-2780, replacing the previous flat 21,000, and calldata_gas follows EIP-7976's uniform per-byte floor (64 gas/byte). The scheme surcharge replaces the ECRECOVER portion of the EIP-2780 base cost; it is 0 for SCHEME_SECP256K1 and 5,000 for SCHEME_EPHEMERAL_K1. EXT_SET_CODE adds a fixed 25,000 gas per authorization and refunds 12,500 for each non-empty authority that is processed successfully. EXT_BLOB reuses EIP-4844's blob fee lane and accounting. The extra burden of a non-secp256k1 scheme is the calldata cost of the witness size difference plus the scheme surcharge; the ephemeral scheme's witness is 737 bytes, so (737 - 65) x 64 = 43,008 gas, plus 5,000 gas. The verification cost is one ecrecover plus Keccak-256 hashing EPHEMERAL_TREE_DEPTH times for the Merkle proof.

Validation order and backward compatibility

Nodes validate in a fixed order: check the type byte (0x05), decode the RLP, check chain_id, check authorization structure (exactly one ROLE_SENDER, unknown role_id or scheme_id invalid), check extension structure (duplicate or unknown extension_id invalid, state-independent payload consistency), verify the sender, check nonce and balance (including per-extension fee lanes), process extensions before execution (EXT_BLOB checks, applying EXT_SET_CODE authorizations), charge intrinsic gas, and finally execute a normal call or creation using to, value, and data. On backward compatibility, a SchemedTransaction using SCHEME_SECP256K1 has the same sender address and execution semantics as an ordinary EIP-1559 transaction; only the envelope and signing hash differ. A contract sees the same msg.sender and tx.origin derived address regardless of which scheme was used. By contrast, moving from secp256k1 to the ephemeral scheme yields a new address, since the address is derived from the Merkle root.

Progress status

This EIP is in Draft status, created on March 22, 2026, so the specification may still change, and the Test Cases section of the source is also empty. There is no record of a core developer call deciding on fork inclusion. The extension model is open, and the source notes that an EIP-8141-style frame extension could also be attached to the same envelope under a new extension_id. role_id, scheme_id, and extension_id each occupy the space 0x00 through 0xFF, and new values must be assigned via a separate EIP.

Original EIP · ← EIPs