EIP-8197 Cryptographically Agile Transaction (CATX) (Cryptographically Agile Transactions)
No call decision · Security & privacy · EIP status Draft · created 2025-03-04
Introduces CATX, a new transaction format that separates the transaction body from the signature. Because the signing algorithm can be changed independently of transaction semantics, it prepares the ground for post-quantum cryptography migration, multi-signatures, and zero-knowledge signature aggregation.
Why it is needed
In Ethereum transactions today, the signature value is embedded together in the body fields. Because the body and signature are attached, adopting a new signing algorithm requires creating a new transaction type each time. The source points out three problems this structure creates. First, even to switch signatures to post-quantum cryptography, the transaction specification must be redefined. Second, in transactions signed by multiple parties, a key substitution attack is possible, where one signature is swapped for another to change the meaning of authorization. Third, aggregation techniques that combine multiple signatures into one using zero-knowledge proofs require the signature to be cleanly separable, which is difficult with the current format. CATX solves all three problems at once with a flat structure that appends signature pairs after the body.
What changes
Today
- The signature value is embedded inside the transaction body fields
- A new transaction type must be created for each new signing algorithm
- There is a risk of signature substitution (key substitution) in multi-signatures
- It is difficult to separate out just the signature and replace it with zero-knowledge aggregation
After EIP-8197
- Appends (signature type, signature data) pairs after the body
- Adding only the signature type lets the same body format be reused as is
- Each signature hashes in all preceding signatures, which breaks substitution attacks
- The trailing signature can be removed and replaced with an aggregation proof
Who is affected
- Wallet & app developers: Signing logic must be implemented to match the new rule that prefixes CA_TX_TYPE to the signature hash, and existing transactions must be re-signed to convert them to CATX.
- Client teams: Must implement parsing of the new transaction type's encoding, exact-match verification of the signature count, and address derivation rules per signature type.
- Researchers / aggregation services: Because the body remains intact even after the trailing signature is removed, designing zero-knowledge signature aggregation becomes easier.
- Users: Transactions in use today stay as they are, but in the long run this becomes the foundation for multi-signature features such as post-quantum signatures or fee sponsorship.
In depth
Flat encoding structure
A CATX transaction is encoded as CA_TX_TYPE || rlp([payload_type, payload_body, (sig_type, sig_body)+]). The body comes first, followed by signature type and signature data pairs laid out flat. The payload determines how many signatures are required, either fixed per payload_type or set by a field inside payload_body, and if the signature count does not exactly match the requirement, the transaction is invalid. The CA_TX_TYPE value is still TBD. The flat structure was chosen so that payload types and signature algorithms can be extended independently of each other without unnecessary RLP nesting.
Four payload types, legacy excluded
Four payload types are supported. 0x01 is EIP-2930, 0x02 is EIP-1559, 0x03 is EIP-4844, and 0x04 is EIP-7702 format, and all require exactly one signature. payload_body is identical to the signing form of each transaction type, and the meaning of the fields and the validation rules are governed entirely by the corresponding EIP. Legacy (type 0) transactions are not supported, because in the legacy format the payload information is encoded into the signature itself, making it impossible to cleanly separate body and signature.
Chained signature hash and defense against key substitution
Each signature commits to the payload and to every signature that precedes it. payload_commitment is CA_TX_TYPE || rlp(payload_type) || rlp(payload_body), the first signature signs keccak256(payload_commitment), and the i-th signature signs the hash of that value concatenated with all preceding (sig_type, sig_body) pairs. As a result, swapping out an earlier signature breaks every signature after it, and reordering signatures changes the hash input and causes verification to fail. This guards against key substitution attacks (Fujita et al., IACR ePrint 2024/1728), in which a signature in a multi-signature scheme is swapped or reordered to change the meaning of the authorization. For example, a fee payer includes the sender's signature inside their own signature hash, so they only pay fees for a transaction actually signed by the sender they expected.
ECDSA signature type 0x00 separated from the registry
ECDSA (secp256k1) signature type 0x00 is defined in this EIP as a bootstrap so the format can be used immediately. sig_body must be exactly 65 bytes: y_parity[1] || r[32] || s[32]; any other length is invalid. y_parity uses 0/1 rather than the legacy v value (27/28), and any other value is invalid. The existing rule that s must be in the lower half of the curve order still applies. Assigning which sig_type number maps to which algorithm is out of scope for this EIP and is handled by a separate registry EIP such as EIP-7932; if the registry conflicts with the ECDSA type definition here, the registry takes precedence. Any EIP defining a new signature type must also specify gas adjustments relative to ECDSA verification cost and adjustments for differences in signature size.
Address derivation per signature type
Address derivation differs by signature type. ECDSA (0x00) keeps the existing method, keccak256(uncompressed_pubkey)[12:32], for backwards compatibility. Non-ECDSA types include sig_type in the hash input, as in keccak256(sig_type || public_key)[12:32]. If the public key is 63 bytes, a single 0x00 byte is inserted between sig_type and the key. Otherwise the input would be 64 bytes, the same length as an ECDSA 64-byte public key, creating a collision risk. This separates the address space per algorithm, preventing attacks where key format collisions between different algorithms are used to claim control of an address created under a different scheme. This is consistent with EIP-7932.
EIP-7702 authorization list handling
The authorization_list in a type 0x04 payload contains CATX-format authorization tuples [[SET_CODE_AUTH_TYPE, [chain_id, address, nonce], sig_type, sig_body], ...]. SET_CODE_AUTH_TYPE is 0x05, matching EIP-7702's MAGIC value, so the authorization signature hash keccak256(rlp(SET_CODE_AUTH_TYPE) || rlp([chain_id, address, nonce])) is identical to EIP-7702's. This allows existing ECDSA authorization signatures to be converted directly to CATX format without re-signing, and the source explains that this is an intentional, safe design because the meaning of the authorization is the same regardless of format. Because the authorization signature commits to the delegation tuple rather than the whole transaction, it is embedded inside payload_body rather than being a trailing signature. This distinguishes it from trailing signatures, which can be stripped off for ZK aggregation, since embedded signatures are part of the payload's meaning.
Domain separation and compatibility with existing formats
Because CA_TX_TYPE is prefixed to payload_commitment, CATX signatures and existing-format signatures are not interchangeable. An existing EIP-1559 signature signs keccak256(0x02 || rlp([...])), while a CATX signature over the same payload signs keccak256(CA_TX_TYPE || 0x02 || rlp([...])), so a signature from one format cannot be reused in the other. Existing EIP-2930, 1559, 4844, and 7702 transactions can be converted to CATX format, but they must be re-signed. Receipts use the common format CA_TX_TYPE || rlp([status, cumulative_gas_used, logs_bloom, logs]), and the transaction hash is the keccak256 of the entire encoding. Gas costs follow each payload's original EIP rules, and ECDSA signatures incur no additional cost.
Draft status and remaining decisions
This EIP is currently in Draft status, so its contents may still change. The core parameter, the CA_TX_TYPE value, remains TBD. The source deliberately scopes this EIP to the transaction format (encoding, signature hash chaining, address derivation), leaving algorithm assignment, sig_body encoding rules, and gas adjustments for new signature types to dedicated registry EIPs such as EIP-7932. This is so that matters that evolve independently of the format are not locked into the format specification. There is no record in the provided material of a core developer call deciding to include this EIP in a specific fork.