EIP-7591 BLS-signed transactions (BLS signed transactions)
No call decision · Scaling & data · EIP status Stagnant · created 2024-01-10
A proposal to introduce a new transaction type (0x04) that uses BLS signatures, aggregating the signatures of every BLS transaction in a block into one to reduce block size.
Why it is needed
Ethereum transactions currently use ECDSA signatures, and since each transaction's signature is stored separately in the block, the chain's overall storage footprint keeps growing. BLS signatures have the mathematical property that multiple signatures can be combined (aggregated) and verified all at once. If transactions in a block use BLS signatures, the signature data that used to grow with the number of transactions can be reduced to a single signature carried in the block header. This proposal also serves as a precedent showing the structure for adding a new signing scheme to transactions, which means a similar approach could later be used to introduce a quantum-resistant signature scheme as well.
What changes
Today
- Each transaction carries its own ECDSA signature individually, and each is verified separately.
- The signature scheme usable in a transaction is fixed to ECDSA alone.
- Each transaction uses about 65 bytes for its signature.
After EIP-7591
- The new transaction type (0x04) carries the sender's BLS public key (sender) instead of a signature, and the actual signature is delivered collected into a single aggregated_sig field in the block header.
- When validating a block, the signatures of every BLS transaction in the block are verified all at once in a single operation (verifyAggregate).
- It uses a BLS public key (48 bytes) and an aggregated signature (96 bytes), saving bytes compared to ECDSA as the number of transactions grows.
Who is affected
- Wallet & app developers: Supporting BLS keys requires newly implementing the serialization and signing logic for the new transaction type (0x04).
- Client teams: Logic must be added to collect and aggregate the signatures of BLS transactions when building a block, and to verify them all at once with verifyAggregate.
- Validators: Block validation must also account for the newly added aggregated_sig field in the block header.
- Ordinary users: Chain data may get slightly lighter, but it is not a noticeably perceptible change.
In depth
Transaction format and type number
BLS_TX_TYPE is 0x04. A transaction has the structure [chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, data, access_list, sender, signature]. Instead of the existing transaction's signature fields (v, r, s), the sender field itself carries the account's BLS public key, and signature is kept as a separate field. The account's address is address = [0:20](keccak256(sender)), i.e. the last 20 bytes of the keccak256 hash of the BLS public key.
Calculating the hash to be signed
The hash to be signed is computed as tx_hash = keccak256(BLS_TX_TYPE || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, data, access_list, sender])). The signature field is not included in this hash computation, and the BLS signature is generated directly over this tx_hash.
The aggregated_sig field added to the header
A new aggregated_sig field is added to the block header. The RLP-encoded header takes the form of parent_hash, ommers_hash, coinbase, state_root, txs_root, receipts_root, logs_bloom, difficulty(0), number, gas_limit, gas_used, timestamp, extradata, prev_randao, nonce(0x0000000000000000), base_fee_per_gas, withdrawals_root, blob_gas_used, excess_blob_gas, followed by aggregated_sig at the end.
Block creation and validation rules
When building a block, all BLS transactions are included with the signature field unset. A block containing a BLS transaction whose signature field is filled in MUST be rejected. When validating a block, valid = verifyAggregate(sender_1, ... sender_n, tx_hash_1, ... tx_hash_n, aggregated_sig) verifies, in one pass, the sender public keys and tx_hash of every BLS transaction in the block together with the header's aggregated_sig.
Byte savings calculation
Removing the ECDSA signature saves 65 bytes per transaction, but a new 48-byte BLS public key is required and a 96-byte aggregated signature is added once per block. That is, -96 + (65-48) × number of transactions bytes saved per block. Assuming roughly 7,000 blocks and roughly 1,000,000 transactions per day, for an average of about 150 transactions per block, this saves about 2,454 bytes (2.4KB) per block, roughly a 1.5% reduction against an average block size of 160KB.
Security consideration: impossibility of address collision
Since the message signed with BLS (tx_hash) differs for every transaction, there are no hash collisions, so signature aggregation is safe even without proof-of-possession. The fact that BLS does not require public keys to be distinct from one another is also not an issue. Assuming keccak256, ECDSA, and BLS are each secure, for an address derived from an ECDSA public key to equal an address derived from a BLS public key, the two public keys themselves would have to be equal, which is equivalent to breaking the security of BLS or ECDSA and is therefore practically impossible. In other words, a situation where an ECDSA private key and a BLS private key simultaneously control the same account cannot occur.
Backward compatibility and current status
This proposal changes the execution layer's block validation rules and adds a new transaction type and a new header field, so it requires a hard fork. The document status is Stagnant, meaning discussion is not actively progressing. No call records addressing fork inclusion have been found, and it is not currently a proposal moving toward standard adoption.