messages.hpp¶

Namespaces¶

Name
eth
eth::protocol

Types¶

	Name
using std::vector< uint8_t >	ByteBuffer
using rlp::EncodingResult< ByteBuffer >	EncodeResult
template <typename T > using rlp::Result< T >	DecodeResult
using rlp::outcome::result< void, eth::StatusValidationError, rlp::outcome::policy::all_narrow >	ValidationResult Result type for Status validation (void on success, error on mismatch). Uses boost::outcome with StatusValidationError — mirrors go-ethereum's readStatus() return values from eth/protocols/eth/handshake.go.

Functions¶

	Name
ValidationResult	validate_status(const eth::StatusMessage & msg, uint64_t expected_network_id, const eth::Hash256 & expected_genesis) Validate a decoded StatusMessage against our expected chain parameters.
EncodeResult	encode_status(const StatusMessage & msg)
DecodeResult< StatusMessage >	decode_status(rlp::ByteView rlp_data)
EncodeResult	encode_new_block_hashes(const NewBlockHashesMessage & msg)
DecodeResult< NewBlockHashesMessage >	decode_new_block_hashes(rlp::ByteView rlp_data)
EncodeResult	encode_new_pooled_tx_hashes(const NewPooledTransactionHashesMessage & msg)
DecodeResult< NewPooledTransactionHashesMessage >	decode_new_pooled_tx_hashes(rlp::ByteView rlp_data)
EncodeResult	encode_get_block_headers(const GetBlockHeadersMessage & msg)
DecodeResult< GetBlockHeadersMessage >	decode_get_block_headers(rlp::ByteView rlp_data)
EncodeResult	encode_block_headers(const BlockHeadersMessage & msg)
DecodeResult< BlockHeadersMessage >	decode_block_headers(rlp::ByteView rlp_data)
EncodeResult	encode_get_block_bodies(const GetBlockBodiesMessage & msg)
DecodeResult< GetBlockBodiesMessage >	decode_get_block_bodies(rlp::ByteView rlp_data)
EncodeResult	encode_block_bodies(const BlockBodiesMessage & msg)
DecodeResult< BlockBodiesMessage >	decode_block_bodies(rlp::ByteView rlp_data)
EncodeResult	encode_new_block(const NewBlockMessage & msg)
DecodeResult< NewBlockMessage >	decode_new_block(rlp::ByteView rlp_data)
EncodeResult	encode_get_receipts(const GetReceiptsMessage & msg)
DecodeResult< GetReceiptsMessage >	decode_get_receipts(rlp::ByteView rlp_data)
EncodeResult	encode_receipts(const ReceiptsMessage & msg)
DecodeResult< ReceiptsMessage >	decode_receipts(rlp::ByteView rlp_data)
EncodeResult	encode_get_pooled_transactions(const GetPooledTransactionsMessage & msg)
DecodeResult< GetPooledTransactionsMessage >	decode_get_pooled_transactions(rlp::ByteView rlp_data)
EncodeResult	encode_pooled_transactions(const PooledTransactionsMessage & msg)
DecodeResult< PooledTransactionsMessage >	decode_pooled_transactions(rlp::ByteView rlp_data)

Attributes¶

	Name
uint8_t	kStatusMessageId
std::chrono::seconds	kStatusHandshakeTimeout Maximum time to wait for a peer's ETH Status after sending ours. Matches go-ethereum's handshakeTimeout (eth/protocols/eth/handshake.go). If the peer does not reply within this window it is dropped as malicious or mismatched (e.g. a Polygon bor node on the Ethereum P2P network).
uint8_t	kNewBlockHashesMessageId
uint8_t	kTransactionsMessageId
uint8_t	kGetBlockHeadersMessageId
uint8_t	kBlockHeadersMessageId
uint8_t	kGetBlockBodiesMessageId
uint8_t	kBlockBodiesMessageId
uint8_t	kNewBlockMessageId
uint8_t	kNewPooledTransactionHashesMessageId
uint8_t	kGetPooledTransactionsMessageId
uint8_t	kPooledTransactionsMessageId
uint8_t	kGetReceiptsMessageId
uint8_t	kReceiptsMessageId

Types Documentation¶

using ByteBuffer¶

using eth::protocol::ByteBuffer = std::vector<uint8_t>;

using EncodeResult¶

using eth::protocol::EncodeResult = rlp::EncodingResult<ByteBuffer>;

using DecodeResult¶

template <typename T >
using eth::protocol::DecodeResult = rlp::Result<T>;

using ValidationResult¶

using eth::protocol::ValidationResult = rlp::outcome::result<void, eth::StatusValidationError,
                                              rlp::outcome::policy::all_narrow>;

Result type for Status validation (void on success, error on mismatch). Uses boost::outcome with StatusValidationError — mirrors go-ethereum's readStatus() return values from eth/protocols/eth/handshake.go.

Functions Documentation¶

function validate_status¶

ValidationResult validate_status(
    const eth::StatusMessage & msg,
    uint64_t expected_network_id,
    const eth::Hash256 & expected_genesis
)

Validate a decoded StatusMessage against our expected chain parameters.

Parameters:

msg The decoded peer Status message (variant).
expected_network_id Our chain's network ID.
expected_genesis Our chain's genesis block hash.

Return: Success, or the first validation error encountered.

Mirrors go-ethereum's readStatus() checks (handshake.go):

NetworkID must match expected_network_id
Genesis must match expected_genesis
For ETH/69: EarliestBlock must be <= LatestBlock (when LatestBlock != 0)

function encode_status¶

EncodeResult encode_status(
    const StatusMessage & msg
)

function decode_status¶

DecodeResult< StatusMessage > decode_status(
    rlp::ByteView rlp_data
)

function encode_new_block_hashes¶

EncodeResult encode_new_block_hashes(
    const NewBlockHashesMessage & msg
)

function decode_new_block_hashes¶

DecodeResult< NewBlockHashesMessage > decode_new_block_hashes(
    rlp::ByteView rlp_data
)

function encode_new_pooled_tx_hashes¶

EncodeResult encode_new_pooled_tx_hashes(
    const NewPooledTransactionHashesMessage & msg
)

function decode_new_pooled_tx_hashes¶

DecodeResult< NewPooledTransactionHashesMessage > decode_new_pooled_tx_hashes(
    rlp::ByteView rlp_data
)

function encode_get_block_headers¶

EncodeResult encode_get_block_headers(
    const GetBlockHeadersMessage & msg
)

function decode_get_block_headers¶

DecodeResult< GetBlockHeadersMessage > decode_get_block_headers(
    rlp::ByteView rlp_data
)

function encode_block_headers¶

EncodeResult encode_block_headers(
    const BlockHeadersMessage & msg
)

function decode_block_headers¶

DecodeResult< BlockHeadersMessage > decode_block_headers(
    rlp::ByteView rlp_data
)

function encode_get_block_bodies¶

EncodeResult encode_get_block_bodies(
    const GetBlockBodiesMessage & msg
)

function decode_get_block_bodies¶

DecodeResult< GetBlockBodiesMessage > decode_get_block_bodies(
    rlp::ByteView rlp_data
)

function encode_block_bodies¶

EncodeResult encode_block_bodies(
    const BlockBodiesMessage & msg
)

function decode_block_bodies¶

DecodeResult< BlockBodiesMessage > decode_block_bodies(
    rlp::ByteView rlp_data
)

function encode_new_block¶

EncodeResult encode_new_block(
    const NewBlockMessage & msg
)

function decode_new_block¶

DecodeResult< NewBlockMessage > decode_new_block(
    rlp::ByteView rlp_data
)

function encode_get_receipts¶

EncodeResult encode_get_receipts(
    const GetReceiptsMessage & msg
)

function decode_get_receipts¶

DecodeResult< GetReceiptsMessage > decode_get_receipts(
    rlp::ByteView rlp_data
)

function encode_receipts¶

EncodeResult encode_receipts(
    const ReceiptsMessage & msg
)

function decode_receipts¶

DecodeResult< ReceiptsMessage > decode_receipts(
    rlp::ByteView rlp_data
)

function encode_get_pooled_transactions¶

EncodeResult encode_get_pooled_transactions(
    const GetPooledTransactionsMessage & msg
)

function decode_get_pooled_transactions¶

DecodeResult< GetPooledTransactionsMessage > decode_get_pooled_transactions(
    rlp::ByteView rlp_data
)

function encode_pooled_transactions¶

EncodeResult encode_pooled_transactions(
    const PooledTransactionsMessage & msg
)

function decode_pooled_transactions¶

DecodeResult< PooledTransactionsMessage > decode_pooled_transactions(
    rlp::ByteView rlp_data
)

Attributes Documentation¶

variable kStatusMessageId¶

uint8_t kStatusMessageId = 0x00;

variable kStatusHandshakeTimeout¶

std::chrono::seconds kStatusHandshakeTimeout {5};

Maximum time to wait for a peer's ETH Status after sending ours. Matches go-ethereum's handshakeTimeout (eth/protocols/eth/handshake.go). If the peer does not reply within this window it is dropped as malicious or mismatched (e.g. a Polygon bor node on the Ethereum P2P network).

variable kNewBlockHashesMessageId¶

uint8_t kNewBlockHashesMessageId = 0x01;

variable kTransactionsMessageId¶

uint8_t kTransactionsMessageId = 0x02;

variable kGetBlockHeadersMessageId¶

uint8_t kGetBlockHeadersMessageId = 0x03;

variable kBlockHeadersMessageId¶

uint8_t kBlockHeadersMessageId = 0x04;

variable kGetBlockBodiesMessageId¶

uint8_t kGetBlockBodiesMessageId = 0x05;

variable kBlockBodiesMessageId¶

uint8_t kBlockBodiesMessageId = 0x06;

variable kNewBlockMessageId¶

uint8_t kNewBlockMessageId = 0x07;

variable kNewPooledTransactionHashesMessageId¶

uint8_t kNewPooledTransactionHashesMessageId = 0x08;

variable kGetPooledTransactionsMessageId¶

uint8_t kGetPooledTransactionsMessageId = 0x09;

variable kPooledTransactionsMessageId¶

uint8_t kPooledTransactionsMessageId = 0x0a;

variable kGetReceiptsMessageId¶

uint8_t kGetReceiptsMessageId = 0x0f;

variable kReceiptsMessageId¶

uint8_t kReceiptsMessageId = 0x10;

Source code¶

// Copyright 2025 GeniusVentures
// SPDX-License-Identifier: Apache-2.0

#pragma once

#include "eth_types.hpp"
#include <rlp/rlp_encoder.hpp>
#include <rlp/rlp_decoder.hpp>
#include <chrono>
#include <vector>

namespace eth::protocol {

inline constexpr uint8_t kStatusMessageId = 0x00;

inline constexpr std::chrono::seconds kStatusHandshakeTimeout{5};
inline constexpr uint8_t kNewBlockHashesMessageId = 0x01;
inline constexpr uint8_t kTransactionsMessageId = 0x02;
inline constexpr uint8_t kGetBlockHeadersMessageId = 0x03;
inline constexpr uint8_t kBlockHeadersMessageId = 0x04;
inline constexpr uint8_t kGetBlockBodiesMessageId = 0x05;
inline constexpr uint8_t kBlockBodiesMessageId = 0x06;
inline constexpr uint8_t kNewBlockMessageId = 0x07;
inline constexpr uint8_t kNewPooledTransactionHashesMessageId = 0x08;
inline constexpr uint8_t kGetPooledTransactionsMessageId = 0x09;
inline constexpr uint8_t kPooledTransactionsMessageId = 0x0a;
inline constexpr uint8_t kGetReceiptsMessageId = 0x0f;
inline constexpr uint8_t kReceiptsMessageId = 0x10;

using ByteBuffer = std::vector<uint8_t>;
using EncodeResult = rlp::EncodingResult<ByteBuffer>;

template <typename T>
using DecodeResult = rlp::Result<T>;

using ValidationResult = rlp::outcome::result<void, eth::StatusValidationError,
                                               rlp::outcome::policy::all_narrow>;

[[nodiscard]] ValidationResult validate_status(
    const eth::StatusMessage& msg,
    uint64_t                  expected_network_id,
    const eth::Hash256&       expected_genesis) noexcept;

// STATUS
[[nodiscard]] EncodeResult encode_status(const StatusMessage& msg) noexcept;
[[nodiscard]] DecodeResult<StatusMessage> decode_status(rlp::ByteView rlp_data) noexcept;

// NEW_BLOCK_HASHES
[[nodiscard]] EncodeResult encode_new_block_hashes(const NewBlockHashesMessage& msg) noexcept;
[[nodiscard]] DecodeResult<NewBlockHashesMessage> decode_new_block_hashes(rlp::ByteView rlp_data) noexcept;

// NEW_POOLED_TRANSACTION_HASHES
[[nodiscard]] EncodeResult encode_new_pooled_tx_hashes(const NewPooledTransactionHashesMessage& msg) noexcept;
[[nodiscard]] DecodeResult<NewPooledTransactionHashesMessage> decode_new_pooled_tx_hashes(rlp::ByteView rlp_data) noexcept;

// GET_BLOCK_HEADERS
[[nodiscard]] EncodeResult encode_get_block_headers(const GetBlockHeadersMessage& msg) noexcept;
[[nodiscard]] DecodeResult<GetBlockHeadersMessage> decode_get_block_headers(rlp::ByteView rlp_data) noexcept;

// BLOCK_HEADERS
[[nodiscard]] EncodeResult encode_block_headers(const BlockHeadersMessage& msg) noexcept;
[[nodiscard]] DecodeResult<BlockHeadersMessage> decode_block_headers(rlp::ByteView rlp_data) noexcept;

// GET_BLOCK_BODIES
[[nodiscard]] EncodeResult encode_get_block_bodies(const GetBlockBodiesMessage& msg) noexcept;
[[nodiscard]] DecodeResult<GetBlockBodiesMessage> decode_get_block_bodies(rlp::ByteView rlp_data) noexcept;

// BLOCK_BODIES
[[nodiscard]] EncodeResult encode_block_bodies(const BlockBodiesMessage& msg) noexcept;
[[nodiscard]] DecodeResult<BlockBodiesMessage> decode_block_bodies(rlp::ByteView rlp_data) noexcept;

// NEW_BLOCK
[[nodiscard]] EncodeResult encode_new_block(const NewBlockMessage& msg) noexcept;
[[nodiscard]] DecodeResult<NewBlockMessage> decode_new_block(rlp::ByteView rlp_data) noexcept;

// GET_RECEIPTS
[[nodiscard]] EncodeResult encode_get_receipts(const GetReceiptsMessage& msg) noexcept;
[[nodiscard]] DecodeResult<GetReceiptsMessage> decode_get_receipts(rlp::ByteView rlp_data) noexcept;

// RECEIPTS
[[nodiscard]] EncodeResult encode_receipts(const ReceiptsMessage& msg) noexcept;
[[nodiscard]] DecodeResult<ReceiptsMessage> decode_receipts(rlp::ByteView rlp_data) noexcept;

// GET_POOLED_TRANSACTIONS
[[nodiscard]] EncodeResult encode_get_pooled_transactions(const GetPooledTransactionsMessage& msg) noexcept;
[[nodiscard]] DecodeResult<GetPooledTransactionsMessage> decode_get_pooled_transactions(rlp::ByteView rlp_data) noexcept;

// POOLED_TRANSACTIONS
[[nodiscard]] EncodeResult encode_pooled_transactions(const PooledTransactionsMessage& msg) noexcept;
[[nodiscard]] DecodeResult<PooledTransactionsMessage> decode_pooled_transactions(rlp::ByteView rlp_data) noexcept;

} // namespace eth::protocol

Updated on 2026-04-13 at 23:22:46 -0700