EIP-8164 EOA native key delegation (Native Key Delegation for EOAs)

No call decision · Account abstraction · EIP status Draft · created 2026-02-17

Allows an EOA's authentication method to be permanently switched from ECDSA to ML-DSA-44, a NIST-standard quantum-resistant signature scheme. Introduces a new code prefix 0xef0101 and transaction type 0x06.

Why it is needed

Until now, Ethereum's regular accounts (EOAs) could only use one signature scheme: ECDSA over the secp256k1 curve. Once a sufficiently powerful quantum computer exists, this scheme allows the private key to be derived back from the public key. In addition, security chips and hardware security modules increasingly support other signature schemes by default, so mandating ECDSA alone complicates the integration layer and increases the number of trusted components. Smart contract wallets or EIP-7702 code delegation can implement other authentication methods, but they incur cost because the EVM must execute code every time a transaction is verified. This EIP moves signature verification into the protocol itself, allowing a single transaction to permanently switch account authentication to ML-DSA-44. It further allows creating accounts where an ECDSA key never existed in the first place, guaranteeing mathematically rather than procedurally that no backdoor key exists.

What changes

Today

After EIP-8164

Who is affected

In depth

Extending the delegation designator space

EIP-7702 marks code delegation by placing 0xef0100 || address (23 bytes) in the account code slot. This EIP extends the same 0xef01XX namespace, defining 0xef0101 as the prefix for ML-DSA-44 native key accounts. An account whose code is exactly 1,315 bytes in the form 0xef0101 || pubkey (3-byte prefix plus a 1,312-byte public key) is a native key account, and all subsequent transaction authentication uses this public key. The range from 0xef0102 to 0xef01ff is reserved for future signature schemes. The reason each scheme gets its own prefix is that fixed code length allows verification without parsing, each scheme can be activated independently via its own EIP, and the prefix alone fully determines the verification algorithm.

Dual authentication modes for type 0x06 transactions

A single new EIP-2718 transaction type, 0x06, handles both key conversion and native key sending. The sender field is the discriminator. If sender is empty, it operates in ECDSA mode, recovering the sender via ecrecover from a 65-byte signature (y_parity || r || s). If sender is a 20-byte address, it operates in ML-DSA-44 mode, checking that the account's code is 1,315 bytes starting with 0xef0101, then verifying a 2,420-byte signature according to FIPS 204 Algorithm 3 using the public key extracted from the code. In this case ML_DSA_44_VERIFY_COST (50,000) is added to the intrinsic gas. Common fields follow EIP-4844 semantics, and a transaction with a null 'to' is invalid. ML-DSA-44 cannot recover a public key from a signature, which is why sender must be specified explicitly, and this also removes the need for elliptic curve operations during deserialization.

Two kinds of authorization tuples and their processing rules

The authorization list accepts two formats distinguished by element count. The ECDSA-signed tuple used for initial conversion has 6 elements [chain_id, pubkey, nonce, y_parity, r, s], and the authority is recovered via ecrecover from the message keccak256(0x07 || rlp([chain_id, pubkey, nonce])). The native key tuple used for key rotation has 5 elements [chain_id, new_pubkey, nonce, authority, signature], explicitly specifying authority and verifying with the currently installed key; authority is included in the signed message to prevent cross-account reuse. Processing happens after the sender's nonce is incremented, before execution. It checks whether chain_id is 0 or matches the current chain, whether pubkey is 1,312 bytes, and whether the nonce is below 2^64-1 and matches the account's nonce, among other checks; if these pass, the nonce is incremented and the code is installed. Gas costs PER_NATIVE_AUTH_BASE_COST (12,500) per tuple, plus PER_EMPTY_ACCOUNT_COST (25,000) if the account was previously empty. If multiple tuples target the same authority, the last valid tuple wins.

Permanent ECDSA rejection and its rationale

Once an account's code is set to 0xef0101 || pubkey, any ECDSA-signed transaction (type 0x00 through 0x04, or the ECDSA mode of type 0x06) for which that account is the recovered sender is rejected at the validation stage, and any EIP-7702 authorization tuple naming that account as authority is also rejected. The original ECDSA key loses its protocol-level meaning regardless of whether it is still held. The source describes this permanence as a safe design choice: since the new key is the root key, the owner can always replace it via a native key signature tuple, so there is no loss of control, whereas if the conversion could be reversed, a leaked or quantum-broken ECDSA key would leave open a 'dormant key' attack path that could revert the delegation and seize the account. It also means validators can determine the authentication method just by looking at the code prefix, without needing to track historical key state.

Rootless accounts created with a crafted signature

You can create an account whose ECDSA private key no one has ever held. It works on the same principle as Nick's method (ERC-2470), which is used for keyless contract deployment. The creator generates an ML-DSA-44 key pair and computes the authorization message for nonce 0, then picks the x-coordinate of a secp256k1 curve point whose discrete log is unknown as r, picks an arbitrary nonzero value as s, and recovers the address via ecrecover(msg_hash, y_parity, r, s). Fund that address with ETH and submit the tuple as a type 0x06 transaction, and the conversion is complete. Recovering the ECDSA private key would require solving the elliptic curve discrete logarithm problem, which proves there is no backdoor key. The recommended construction derives r from r_seed = keccak256("nkd-v1" || chain_id || pk) and sets s = 1, so third parties can reproduce it and confirm there is no trapdoor. Because the address is deterministic, funds can be deposited before the conversion transaction is sent. Note, however, that a tuple with chain_id = 0 is valid on every chain, so anyone can replay a published tuple on a different chain to install the same account there.

Interaction with the EVM and irrecoverability

For native-key accounts, EXTCODESIZE returns 1315 and EXTCODEHASH returns the keccak256 of the 1,315-byte indicator, and EXTCODECOPY and the account's own CODESIZE/CODECOPY also treat the indicator literally. Calling the account via CALL, CALLCODE, DELEGATECALL, or STATICCALL does not execute any code, so from an execution standpoint it behaves like an EOA. The exception in EIP-3607 is extended so that, alongside 0xef0100, 0xef0101 accounts can also send transactions. A native-key account cannot convert to a 0xef0100 code-delegation account, and since it has no code-execution capability it cannot use batching or smart-contract-based social recovery. Losing the ML-DSA-44 key permanently loses the account and its assets, the same failure mode as losing the key of an ordinary EOA. An indicator that combines authentication with code delegation is left for a future EIP.

Implementation consistency, remaining risks, and Draft status

Because ML-DSA-44 verification bears directly on consensus, the spec pins down strict requirements. Public key and signature encodings must be canonical per FIPS 204, the norm-bound check on the signature vector z must not be skipped or relaxed, and indices in the hint vector h that are duplicated or out of order must be rejected. Every implementation must reach the same verdict on every (pubkey, message, signature) combination, and this must be verified against shared test vectors rather than relying on library defaults. Front-running can only bring the conversion forward in time; it cannot substitute a different key, so its impact is limited. Replay protection is handled by chain_id across chains and by the nonce within a chain. This EIP is currently in Draft status, test cases are not yet defined, and the specification may still change. No call record exists of a decision on fork inclusion.

Original EIP · ← EIPs