EIP-8175 Composable transaction

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

Instead of adding a new transaction type for every new feature, this creates an extensible transaction type that holds features as a list of capabilities. It adds a fee_auth field that lets a third party pay gas on the sender's behalf, and 4 opcodes for signature lookup.

Why it is needed

Ethereum has added a new transaction type with every upgrade: EIP-1559 for priority fees, EIP-4844 for blobs, and EIP-7702 for account delegation, to name a few. Yet EIP-4844 and EIP-7702 each had to define an entirely new type even though they reused most of EIP-1559's fields. At this rate, the number of types keeps growing as features are added, and types with overlapping fee-payment mechanics pile up. Meanwhile, sponsorship, where a third party pays gas on a user's behalf, has long been a requested feature. The existing proposal EIP-8141 implements this using execution frames, several new opcodes, and a per-frame gas budget, whereas this EIP implements the same sponsorship feature with a single, simpler fee_auth field and 4 narrowly scoped opcodes. New features are handled by adding an entry called a capability to a list, so the envelope itself (the transaction format) does not need to change.

What changes

Today

After EIP-8175

Who is affected

In depth

Transaction structure

This defines a new EIP-2718 type, COMPOSABLE_TX_TYPE (0x05). The payload is rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, fee_auth, capabilities, signatures]). The gas-related fields have the same meaning as in EIP-1559. fee_auth is either empty or a 20-byte address, and capabilities is an RLP list of typed capabilities that must contain at least 1 entry. signatures is an RLP list of typed signatures; every signature type must be a known type, and every signature must be cryptographically valid. The receipt payload is rlp([status, cumulative_transaction_gas_used, logs_bloom, logs]). Future EIPs may add new capability types to this format.

Capability types: CALL and CREATE

CAP_CALL (0x01) has the form [cap_type, to, value, data] and executes a message call to an existing account. CAP_CREATE (0x02) has the form [cap_type, value, data] and creates a new contract, with the address derived as keccak256(rlp([sender_address, nonce]))[12:]. Here, nonce is the sender's nonce at the moment that CREATE capability executes, and the sender's nonce is incremented by 1 for each CREATE capability. Capabilities execute in order, and if one reverts, execution of subsequent capabilities stops. By keeping to, value, and data out of the transaction's top-level fields and separating them into capabilities, this design lets the envelope handle only fee payment and authentication, while the actual work becomes composable entries.

Signature separation and roles

Signatures are kept in a signatures array separate from the capabilities. SIG_SECP256K1 (0x01) has the form [signature_type, role, y_parity, r, s], where s must be at most secp256k1n/2 per EIP-2, and the address is recovered via ecrecover. SIG_ED25519 (0x02) has the form [signature_type, role, public_key, signature], verified with pure RFC 8032 Ed25519, with the address being keccak256(public_key)[12:]. role is either ROLE_SENDER (0x00) or ROLE_PAYER (0x01). If fee_auth is empty and there is a ROLE_PAYER signature, the fee is deducted directly from that payer account, enabling a simpler co-signed form of fee sponsorship as well.

Signing hash and domain separation

base_hash is the keccak256 of the entire transaction with the signatures array blinded to an empty list. The actual value being signed, sig_message, is keccak256("\x19ComposableTxSig" || signature_type || role || base_hash). Because the hash is computed with the signatures array blinded, multiple signers can sign independently and in any order; this removes the ordered commitment chain found in earlier designs, simplifying multi-signer flows. Including signature_type and role in sig_message prevents confusion attacks that reinterpret a sender's signature as a payer's signature, or swap it between signature schemes. Because every signature covers the full content including the sender's nonce, replay across transactions is also impossible.

Fee sponsorship via fee_auth

If fee_auth is not empty, the code at that address is called as a prelude before the main execution. The call context is ADDRESS=fee_auth, CALLER and ORIGIN=sender, CALLVALUE=0, CALLDATA empty, with gas equal to gas_limit minus the intrinsic gas. The code must deposit at least gas_limit x max_fee_per_gas into the transaction-scoped fee escrow via RETURNETH. If execution reverts or the deposit is insufficient, the transaction is invalid and cannot be included in a block. After the main execution finishes, only actual_fee = gas_used x effective_gas_price is deducted, and the surplus is refunded to the fee_auth address. State changes made during fee_auth execution persist even if the main transaction reverts, so the sponsor can independently manage its own accounting, such as its own nonce or usage limits.

4 new opcodes

RETURNETH (0xf6, gas 2) subtracts value from the balance of the currently executing account and returns it to the parent call context. If the parent is a normal call, it goes to the caller's balance; if the parent is the top-level fee_auth prelude, it goes to the fee escrow. If the balance is insufficient, it reverts; inside a STATICCALL it halts with an exception; and if the enclosing frame reverts, the deposit is also cancelled. SIG (0xf7, gas 2 + memory expansion) writes the body of signatures[index] to memory and pushes signature_type onto the stack. SIGHASH (0xf8, gas 2) pushes base_hash onto the stack, allowing it to be combined with the data obtained from SIG to verify a signature via ecrecover. TX_GAS_LIMIT (0xf9, gas 2) returns the transaction's gas_limit. Unlike GAS (remaining gas) or GASLIMIT (block gas limit), this provides the transaction's overall limit, allowing the escrow amount to be computed on-chain.

Execution order and gas accounting

The processing order is: static validation, base_hash computation, verification of all signatures and address recovery, checking and incrementing the sender's nonce, checking intrinsic gas, fee handling, sequential execution of capabilities, and settlement. Intrinsic gas is the base 21000 plus the per-capability data cost (16 per non-zero byte, 4 per zero byte), 32000 per CREATE, and 3000 per signature (PER_SIG_SECP256K1_GAS and PER_SIG_ED25519_GAS are both 3000). If fee_auth is set, the gas used by its execution is subtracted from gas_limit before the capabilities execute. At settlement, effective_gas_price is min(max_fee_per_gas, max_priority_fee_per_gas + base_fee); the base fee portion is burned and the priority fee portion goes to the coinbase.

Security considerations and draft status

There is a griefing risk where a fee_auth contract consumes gas without depositing sufficient ETH, invalidating the transaction. To prevent this, block builders may simulate fee_auth before inclusion, and mempool nodes SHOULD simulate the prelude before accepting a transaction; that simulation should limit gas and state access to reduce DoS exposure. Nodes are recommended to keep at most 1 composable transaction per sender in the public mempool. The source states that this level of validation complexity is comparable to EIP-7702 and EIP-8141. This EIP's status is Draft, so details including the type number, opcode numbers, and gas costs may still change. The provided call records contain no fork-inclusion decision for this EIP.

Original EIP · ← EIPs