MESSAGE-FORMATTING

Field	Value
Name	Message Formatting
Slug	89
Status	raw
Category	Standards Track
Editor	Marcin Pawlowski
Contributors	Youngjoon Lee [email protected], Alexander Mozeika [email protected], Álvaro Castro-Castilla [email protected], Filip Dimitrijevic [email protected]

Timeline

2026-08-31 — 5fa8ee4 — docs(blockchain): compress the block proposal with 16-byte transaction reference prefixes (#389)
2026-08-19 — a2a85cb — RFC Bedrock: Cryptarchia with uncle references (#385)
2026-07-03 — 709cf7f — Bedrock-RFC: Remove Concept of a Session (#365)
2026-05-28 — d45eed2 — Chore: mirror blochain specs into github/mdbook (#347)

Revision History

Version	Changes	Date
1.0.0	Initial revision.	2026-04-09
1.0.1	Corrected `Max_Payload_Length` to 34577 bytes, so that it again matches the `Max_Body_Length` of Payload Formatting plus the 3-byte payload header.	2026-08-06
1.0.2	Expressed `Max_Payload_Length` as `Max_Body_Length + 3` rather than a literal, so that it tracks the payload body size automatically; it is 18195 bytes at the `Max_Body_Length` that follows from the compressed transaction references of Block Construction, Validation and Execution.	2026-08-18

Introduction

This document defines an implementation-friendly specification of the Message Formatting, which is introduced in the Formatting section.

In this document we are reusing notation from Notation.

Overview

The message contains a header and a payload. The header informs the protocol about the version of the protocol and the payload type. The message contains a drop or a non-drop payload. The length of a payload is fixed to prevent adversaries from distinguishing types of messages based on their length.

Construction

Message

The Message is a structure that contains a public_header, private_header and a payload.

class Message:
    public_header: PublicHeader,
    private_header: Private_Header,
    payload: bytes

Public Header

The public_header must be generated as the outcome of the Message Encapsulation Mechanism.

The public_header is defined as follows:

class PublicHeader:
    version: byte,
    public_key: PublicKey,
    proof_of_quota: ProofOfQuota,
    signature: Signature

Where:

version=0x01 is version of the protocol.
public_key is $K^{n}_i$ , a public key from the set $\mathbf K^n_h$ as defined in the Message Encapsulation spec.
proof_of_quota is $\pi^{K^{n}_i}_{Q}$ , a corresponding proof of quota for the key $K^{n}_i$ from the $\mathbf K^n_h$ it also contains the key nullifier.
signature is $\sigma_{K^{n}_{i}}(\mathbf {h|P}_i)$ , a signature of the concatenation of the $i$ -th encapsulation of the payload $\mathbf P$ and the private header $\mathbf h$ , that can be verified by the public key $K^{n}_{i}$ .

Private Header

The private_header must be generated as the outcome of the Message Encapsulation Mechanism.

The private header contains a set of encrypted blending headers $\mathbf h = (\mathbf b_1,...,\mathbf b_{h_{max}})$ .

private_header: list[BlendingHeader]

The size of the set is limited to $\beta_{max}=3$ BlendingHeader entries, as defined in the Global Parameters.

The BlendingHeader ( $\mathbf b_l$ ) is defined as follows:

class BlendingHeader:
    public_key: PublicKey,
    proof_of_quota: ProofOfQuota,
    signature: Signature,
    proof_of_selection: ProofOfSelection
    is_last: byte

Where:

public_key is $K^{n}_{l}$ , a public key from the set $\mathbf K^n_h$ .
proof_of_quota is $\pi^{K^{n}_l}_{Q}$ , a corresponding proof of quota for the key $K^{n}_l$ from the $\mathbf K^n_h$ it also contains the key nullifier.
signature is $\sigma_{K^{n}_{l}}(\mathbf {h|P}_l)$ , a signature of the concatenation of $l$ -th encapsulation of the payload $\mathbf P$ and the private header $\mathbf h$ , that can be verified by public key $K^{n}_{l}$ .
proof_of_selection is $\pi^{K^{n}_{l+1},m_{l+1}}_{S}$ , a proof of selection of the node index $m_{l+1}$ assuming valid proof of quota $\pi^{K^{n}_{l}}_{Q}$ .
is_last is $\Omega$ , a flag that indicates that this is the last encapsulation.

Payload

The payload must be formatted according to the Payload Formatting. The formatted payload must be generated as the outcome of the Message Encapsulation Mechanism.

Maximum Payload Length

The Max_Payload_Length parameter defines the maximum length of the payload. It is not an independent parameter: a payload is a 3-byte header followed by a body of exactly Max_Body_Length bytes, so

Max_Payload_Length = Max_Body_Length + 3

which is 18195 bytes at the Max_Body_Length of 18192 currently set by Payload Formatting. Stating it as a derived value rather than a literal means that a change to the maximum block proposal size — which is what sets Max_Body_Length — reaches this parameter without an edit here. More information about payload formatting can be found in Payload Formatting.

Logos LIP