Message Blocks

What is a Message Block?

A message block is a special block type that stores signed data blobs instead of executing transactions. It contains:

• Messages — Array of signed payloads

• Messages Root — Merkle root for consensus verification

• No Transactions — Empty transaction list

• Minimal State Change — Only PMQ fee deductions

Message Structure

Every message contains these fields:

Field	Size	Purpose
sender	20 bytes	Who signed the message
payload	Variable (max 8 KB)	Your data (opaque bytes)
timestamp	8 bytes	When included in block
signature	65 bytes	ECDSA proof of authorship
nonce	8 bytes	Replay protection (same-chain)
chainId	8 bytes	Replay protection (cross-chain)
bid	Variable	Priority fee in wei (0 for standard)

Payload Content

The payload field is opaque bytes. The protocol doesn't interpret it. Your application decides the format:

• Plain text

• JSON

• Protocol Buffers

• Encrypted data

• Any binary format

Maximum size: 8 KB per message (configurable per network).

Block Structure

Message Block Header
├── parentHash
├── stateRoot        ← Updated only for PMQ bid deductions
├── transactionsRoot ← Empty (no transactions)
├── messagesRoot     ← NEW: Merkle root of messages
├── blockType        ← "msg" (metadata, not in hash)
└── ...standard fields

Message Block Body
├── transactions: [] ← Empty array
└── messages: [
    { sender, payload, timestamp, signature, nonce, chainId, bid, hash },
    { sender, payload, timestamp, signature, nonce, chainId, bid, hash },
    ...
]

Block Capacity

Each message block has reserved slots for each queue type:

┌─────────────────────────────────────────────────────────────┐
│                  Message Block (10 MB max)                   │
├─────────────────────────────┬───────────────────────────────┤
│     Priority Slot (5 MB)    │     Standard Slot (5 MB)      │
│     From PMQ only           │     From SMQ only             │
│     Sorted by bid           │     Strict FIFO               │
└─────────────────────────────┴───────────────────────────────┘

Key Property: Slots are independent. If PMQ only fills 2 MB, the unused 3 MB is not given to SMQ. This guarantees block space for both message types.

Capacity Numbers

Metric	Value
Max block size	10 MB
Priority slot	5 MB
Standard slot	5 MB
Max message size	8 KB
Max messages/block	~1,280
Messages per slot	~640 each

Block Assembly

When it's time to build a message block:

1. Pull from PMQ (Priority Queue)
   - Sorted by: bid DESC, then timestamp ASC
   - Fill up to 5 MB
   - Highest bidders first

2. Pull from SMQ (Standard Queue)
   - Strict FIFO order
   - Fill up to 5 MB
   - First in, first out

3. Combine into block
   - Calculate messages_root
   - Deduct PMQ bids from senders
   - Credit proposer (30%) and archive pool (70%)

Verification Layers

Messages are verified at multiple points:

Layer	What's Checked
RPC	Signature, chainId, nonce format, payload size
Queue	Duplicate detection, bid validation
Block Build	Final signature verification
P2P	Signature before gossip
Consensus	messages_root matches content

If any check fails, the message is rejected.

State Changes

Message blocks are unique: they're mostly stateless, but PMQ bids do affect state:

Before Block:
  sender.balance = 10 OBS
  proposer.balance = 100 OBS
  archivePool.balance = 500 OBS

Message with 1 OBS bid included:
  - sender pays 1 OBS
  - proposer gets 0.3 OBS (30%)
  - archivePool gets 0.7 OBS (70%)

After Block:
  sender.balance = 9 OBS
  proposer.balance = 100.3 OBS
  archivePool.balance = 500.7 OBS

Standard messages (bid = 0) cause no state changes.

---

Next: Dual-Lane Queues — Understanding PMQ and SMQ