EIP-8397 Frame authenticator signature (Frame Authenticator Signatures)
No call decision · Account abstraction · EIP status Draft · created 2026-08-26
Adds an AUTHENTICATOR signature scheme to frame transactions (EIP-8141). It lets the protocol execute the expensive cryptographic verification of new authentication methods at fixed gas cost, in a stateless, restricted environment.
Why it is needed
Right now frame transactions (EIP-8141) only have two signature schemes that the protocol verifies directly: secp256k1 and P-256. To use any other authentication method, the proof must be carried as an ARBITRARY entry and verified by the account code directly inside the VERIFY frame. That mixes expensive, state-independent cryptographic computation into the same frame as cheap, state-dependent account authorization checks. Sequencers (the parties who order transactions) and block builders then have a hard time separating this expensive work from account state in order to pre-bound its cost or cache the result. This proposal moves only the expensive, state-independent part into protocol-level verification and attaches a fixed, protocol-defined gas budget so that the cost of every custom authentication signature is statically known. Which authenticator to trust is still decided by the account inside the VERIFY frame, as before.
What changes
Today
- The protocol directly verifies only secp256k1 and P-256 signatures
- Other authentication methods are carried as ARBITRARY and verified by the account code inside the VERIFY frame
- Expensive cryptographic verification and cheap account authorization checks are mixed together in one place, making it hard to bound or cache costs separately
After EIP-8397
- The AUTHENTICATOR(0x03) scheme lets a custom authentication proof be carried in the transaction
- The protocol runs the expensive cryptographic verification in a restricted, state-independent context for a fixed gas cost (AUTHENTICATOR_COST)
- The account only decides in the VERIFY frame whether to trust the authenticator address, and can optionally add key-specific policy using key_id
- Builders and sequencers can classify, cache, or batch authentication work by looking at (authenticator, key_id)
Who is affected
- Wallet and account developers: A new authentication method no longer needs to be verified directly in account code; instead an authenticator contract can be deployed and placed on the protocol verification path. The account only needs to approve the authenticator address.
- Client teams: All clients must implement the pure authentication context's forbidden opcodes, return data validation, gas bounds, and block access list recording identically. Divergence here can lead to consensus failures.
- Builders, sequencers, and node operators: Because the cost per signature is fixed, verification work can be pre-computed, and authentication results can be cached using a key that includes the authenticator code hash. If the authenticator code changes, pending transactions must be re-verified.
- Users: Once an account has approved an authenticator, it opens a path for frame transactions to be authorized using credentials other than secp256k1 or P-256.
In depth
Constants and fixed gas
AUTHENTICATOR uses signature scheme value 0x03. The key_id length is AUTHENTICATOR_HEADER_LENGTH = 32 bytes. Authenticator execution is given AUTHENTICATOR_GAS_LIMIT = 50000 gas, plus AUTHENTICATOR_BASE_COST = COLD_ACCOUNT_ACCESS_COST (the cold account access cost from EIP-2929) for the cost of reading the authenticator code. The reason the numbers reference constants rather than being hardcoded is so that if another EIP adjusts access costs, the signature price moves with it. The total AUTHENTICATOR_COST is 52600 under the current schedule, and neither the transaction nor the authenticator can change this budget. Letting each signature set its own gas would make cost depend on witness content, complicating intrinsic gas calculation and mempool cap calculation; the core of this design is a single limit that makes the maximum cost of any AUTHENTICATOR signature statically known.
Wire format and structural constraints
A signature entry has the form [scheme, signer, msg, signature], where signer is the 20-byte authenticator address and signature is the key_id (32 bytes) followed by a variable-length proof. Unlike SECP256K1 and P256, signer cannot be left empty to default to tx.sender. msg retains EIP-8141 semantics: an empty value selects the canonical frame transaction signing hash, while a 32-byte value selects that explicit digest. Structural validity requires that signer be exactly 20 bytes and not the zero address, that signature be at least 32 bytes, and that key_id be nonzero. The authenticator must have ordinary deployed code; it must not be a precompile and must not carry an EIP-7702 delegation designator. What executes is whatever code is currently deployed at that address.
Pure authentication context
In the authenticator call environment, ADDRESS is the authenticator address, CALLER is EIP-8141's ENTRY_POINT, CALLVALUE is 0, and execution runs in static mode with AUTHENTICATOR_GAS_LIMIT gas. World state reads and writes (BALANCE, SELFBALANCE, SLOAD, SSTORE, TLOAD, TSTORE, EXTCODESIZE, EXTCODECOPY, EXTCODEHASH, SELFDESTRUCT), block-dependent reads (BLOCKHASH, COINBASE, TIMESTAMP, NUMBER, PREVRANDAO, GASLIMIT, BASEFEE, BLOBHASH, BLOBBASEFEE), GASPRICE and ORIGIN, contract creation and non-precompile calls (CREATE, CREATE2, CALL, CALLCODE, DELEGATECALL), and LOG0 through LOG4 are all forbidden; executing any of them invalidates the signature. STATICCALL is allowed only when targeting an active protocol precompile. Any opcode introduced later is forbidden in this context until a separate EIP permits it.
Validation procedure and the SIGPARAM extension
The protocol calls authenticate(digest, proof) and treats the signature as valid only if the return value is exactly 32 bytes and equals the claimed key_id. A zero or different value, malformed return data, a revert, an exceptional halt, running out of gas, or a forbidden operation are all grounds for invalidity. For a valid entry, resolved_signer is the authenticator address, and the verified key_id is stored as a second derived property, fixed before frame execution and immutable afterward. SIGPARAM(0x00) returns the authenticator address, and the newly defined SIGPARAM(0x04) returns the key_id; requesting 0x04 on an entry of a different scheme causes an exceptional halt. Because AUTHENTICATOR is an opaque scheme like SECP256K1 and P256, SIGDATACOPY and SIGPARAM(0x03) are undefined and cause an exceptional halt, so the raw proof is never exposed to the EVM. There is no fallback to ARBITRARY or any other scheme.
Fees and data accounting
signature_gas(sig) = AUTHENTICATOR_COST is fixed, and the full amount is charged whenever the signature is valid, even if the call finishes with leftover gas. This value is also used for the maximum transaction cost, payer reservation, and public mempool verification gas calculations. Because the signature field is not included in the canonical hash, it is charged at the worst-case nonzero-byte rate regardless of byte content: authenticator_signature_tokens(sig) = 4 * len(sig.signature), which is used in place of tokens_in in EIP-8141's signature_data_cost and calldata_tokens calculations. This rule eliminates fee variation based on witness content but leaves variation based on length. Length variability is a property shared by all EIP-8141 canonical-hash witnesses, and authenticators should use the canonical proof encoding and reject proofs with mismatched lengths or meaningless trailing bytes to limit inflation.
Separation of block access lists from warm state
Signature verification runs before any frame. Since reading the authenticator code is a world state access, it must be recorded as a read access under that transaction's block access index per EIP-7928's block access list. Precompiles reached via STATICCALL inside the pure authentication context are not recorded, per EIP-8141's existing rule. Conversely, signature verification must not modify the EIP-2929 warm set, for example by adding the authenticator to accessed_addresses. Warm versus cold status during later frame execution is determined solely by EIP-8141's default initial warm set and accesses made during frame execution. Access list recording and warm state are thus independent: the authenticator appears in that transaction's block access list even if no frame ever touches it.
Public mempool and caching
Mempool rules are policy independent of block validity. AUTHENTICATOR validation adds AUTHENTICATOR_COST, not observed execution gas, into EIP-8141's MAX_VERIFY_GAS. With the current MAX_VERIFY_GAS = 100_000, two AUTHENTICATOR signatures cost 2 * AUTHENTICATOR_COST = 105_200, so a transaction using both sender and sponsor credentials this way could be consensus-valid yet blocked from public mempool propagation. This EIP does not change MAX_VERIFY_GAS; that would require a separate proposal if needed. The only validation dependency for a pending transaction is the authenticator address and its code, so nodes must re-verify if the code changes. A cache key for an authentication result must include at least (chain_id, fork_id, authenticator, authenticator_code_hash, digest, key_id, keccak256(proof)); cache entries built without the code hash must not be used. No registry or allowlist is defined; any authenticator may be accepted, and the maximum waste per invalid signature is bounded by AUTHENTICATOR_GAS_LIMIT.
Security model and proposal status
When an account approves only the authenticator, it is effectively delegating credential selection and proof semantics to that authenticator. An authenticator that accepts arbitrary credentials effectively approves all of them, so accounts that need per-key restrictions can read key_id via SIGPARAM(0x04) and add their own policy. Because key_id and proof are not included in the canonical hash, anyone can substitute them, but forgery is prevented since the authenticator derives key_id from the proof and the protocol checks equality. An authenticator that returns a key_id not cryptographically bound to the proof must not be approved. Code is not fixed, so authenticators whose address can be redeployed with different code should be avoided. An explicit msg signature does not cover the entire transaction, so unless all security-relevant fields are provably committed to, the account must reject it. This proposal is currently in Draft status, so its contents may still change; executable state tests are still to be added, and no call has yet been made on fork inclusion.