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
event BlobBatchRegistered( bytes32 indexed versionedHash, address indexed submitter, bytes32 indexed contentTag, address decoder, address signatureRegistry );: An event emitted when a blob batch is registered, recording the version hash, submitter, contentTag, decoder address, and signature registry address.event CalldataBatchRegistered( bytes32 indexed contentHash, address indexed submitter, bytes32 indexed contentTag, address decoder, address signatureRegistry );: An event emitted when a batch submitted via calldata is registered, recording the content hash, submitter, contentTag, decoder, and signature registry address.function registerBlobBatch( uint256 blobIndex, uint16 startFE, uint16 endFE, bytes32 contentTag, address decoder, address signatureRegistry ) external returns (bytes32 versionedHash);: Registers a blob batch by specifying the segment coordinates within the blob along with the decoder and signature registry addresses.function registerCalldataBatch( bytes calldata batchData, bytes32 contentTag, address decoder, address signatureRegistry ) external returns (bytes32 contentHash);: Registers batch data submitted directly as calldata instead of a blob.function registerBlobBatches(BlobBatchCall[] calldata calls) external returns (bytes32[] memory versionedHashes);: Atomically registers multiple blob batches in a single transaction. If any one fails, the entire transaction reverts.function decode(bytes calldata payload) external view returns (Message[] memory messages, bytes memory signatureData);: Extracts individual messages and signature data from a batch payload. The decoder is an untrusted contract.function register(bytes calldata pubKey, bytes calldata popProof) external returns (uint256 index);: Registers a public key with the signature registry along with proof of possession.function verify( bytes calldata pubKey, bytes32 messageHash, bytes calldata signature ) external view returns (bool valid);: Verifies whether a signature is valid for a given public key and message hash.function verifyAggregated( bytes[] calldata pubKeys, bytes32[] calldata messageHashes, bytes calldata aggregatedSignature ) external view returns (bool valid);: Verifies an aggregate signature (e.g., BLS) over multiple messages at once.event MessageExposed( bytes32 indexed contentHash, bytes32 indexed messageId, address indexed sender, address exposer, uint64 timestamp );: An event emitted when it has been proven on-chain that a specific message exists within a registered batch and that its signature is valid.function isExposed(bytes32 messageId) external view returns (bool exposed);: Looks up whether a given message ID has already been exposed (proven).
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.