ERC-8180 Blob Authenticated Messaging (BAM) standard (Blob Authenticated Messaging)

Draft · Signatures & auth · created 2026-02-21

A standard that cheaply carries signed messages in EIP-4844 blobs and separates trustless decoders from trusted signature registries, so that anyone can read and verify messages.

Why it is needed

Until now, there has been no standard for blob-based messaging, so each implementation defined its own batch registration events, key management contracts, message encoding, and exposure methods. As a result, indexers, wallets, and clients could not interoperate across different implementations and had to rely on each protocol's own off-chain decoder or private API. More seriously, if decoding and signature verification are combined in a single contract, a malicious or buggy decoder (or schema) can always return a valid verification result and impersonate an arbitrary address. Without a standardized decoder/registry separation and a message hashing rule, no one can read messages and cross-verify signatures using only on-chain blockchain data.

What to implement

In depth

Core registration: storage-less, event-based batch registration

registerBlobBatch first calls ERC-8179's declareBlobSegment to validate the segment range within the blob and obtain the versioned hash, then emits BlobBatchRegistered carrying that versioned hash along with the caller (msg.sender), contentTag, decoder address, and signature registry address. registerCalldataBatch takes a calldata batch instead of a blob, using keccak256(batchData) as contentHash, and emits CalldataBatchRegistered. Both functions are permissionless and the core contract stores no state; the event log itself is the only record. contentTag must be included in the event exactly as passed by the caller, cannot be reinterpreted or rejected, and bytes32(0) is allowed (though not recommended).

Separation of the decoder (untrusted) and the signature registry (trusted)

The decoder is an on-chain contract that extracts the message (sender, nonce, contents) and signature data from a blob or calldata payload, but it is untrusted. Even if the decoder decodes the content falsely, the resulting messageHash will not match the actual signature, so only verification fails; a forged message cannot pass through as impersonation. Conversely, the signature registry is a small set of trusted contracts responsible for public key registration and signature verification for a specific signature scheme (ECDSA, BLS, STARK, etc.). If decoding and verification were combined in one contract, a malicious scheme could always return true from verification and impersonate any address, so separating the two is the core design of this ERC.

Message ID, message hash, signing domain

The message ID is computed as keccak256(abi.encodePacked(sender, nonce, contentHash)) and uniquely identifies a message within a batch. The message hash is computed as keccak256(abi.encodePacked(sender, nonce, contents)), and the signing domain is keccak256(abi.encodePacked("ERC-BAM.v1", chainId)), which differs per chain to prevent replay attacks. The value actually signed is signedHash = keccak256(abi.encodePacked(domain, messageHash)). Clients compute these hashes directly from the message the decoder produces before requesting verification from the registry, so they can cross-check rather than trusting the decoder's output blindly. The nonce must increase monotonically per sender; if the same (sender, nonce) pair is duplicated, the message ID collides, so clients must perform their own deduplication.

Signature registry interface

IERC_BAM_SignatureRegistry exposes scheme metadata such as schemeId (a 1-byte identifier: ECDSA 0x01, BLS12-381 0x02, STARK-Poseidon 0x03, Dilithium 0x04), pubKeySize, and signatureSize. register validates proof of ownership before registering the public key, and rejects an already-registered address with AlreadyRegistered. verify returns true if the signature is valid and false otherwise, and may only revert for a malformed signature format. verifyWithRegisteredKey verifies directly against a registered key, and schemes with supportsAggregation set to true (e.g. BLS) can verify multiple signatures at once via verifyAggregated. Extension features such as key rotation or revocation are out of scope for this standard.

Exposer: on-chain proof of an individual message

An Exposer is a contract that proves on-chain that a specific message actually exists within a registered batch and that its signature is valid. On successful proof, it must emit a MessageExposed event carrying contentHash, messageId, sender, exposer, and timestamp, and must reject a message exposed twice with AlreadyExposed. The signature of the expose function itself is not standardized, because the required parameters differ completely depending on the signature scheme and proof method, such as BLS+KZG, ECDSA+Merkle, or STARK+ZK. Instead, the MessageExposed event serves as the interoperability point, so contracts and indexers can react based solely on this event regardless of which proof method is used.

registerBlobBatches: atomic registration of multiple batches

For aggregators that bundle batches from multiple protocols into a single shared blob, registerBlobBatches takes an array of BlobBatchCall, calling declareBlobSegment and emitting BlobBatchRegistered for each entry. If calls.length is 0 it must revert (EmptyBatchArray), and if even one entry fails segment validation the entire transaction must revert so that no partial set of events is emitted. The submitter of every entry must be the same caller, and msg.sender cannot be altered via delegatecall or similar. This function must be mandatorily included in IERC_BAM_Core, but a contract that has not yet implemented the multi-tag path may keep the selector present while reverting with a NotImplemented-style error. No corresponding multi-registration function is defined for calldata batches.

ERC-8179 extension and contentTag indexing

IERC_BAM_Core extends ERC-8179's IERC_BSS, so every BAM contract is simultaneously a BSS contract. registerBlobBatch calls the inherited declareBlobSegment to emit both BlobSegmentDeclared and BlobBatchRegistered together, and the contentTag topic of both events must be identical. In earlier drafts, contentTag was not an indexed topic, so determining which segment in a shared blob belonged to which batch required separately matching log order within the transaction. This version promotes contentTag to the third indexed topic and instead moves decoder to unindexed data, allowing all batches for a specific protocol to be queried with a single eth_getLogs call. This is a breaking change from earlier drafts.

A proposal that has not yet been finalized

This ERC is currently in Draft status; only the number 8180 has been assigned, and details may still change or be discontinued through community discussion and review.

Original ERC · ← ERCs