eth/eth_types.hpp¶

Namespaces¶

Name
eth

Classes¶

	Name
struct	eth::ForkId
struct	eth::StatusMessage68 ETH/68 Status message. Wire: [version, networkid, td, blockhash, genesis, forkid].
struct	eth::StatusMessage69 ETH/69 Status message. Wire: [version, networkid, genesis, forkid, earliestBlock, latestBlock, latestBlockHash].
struct	eth::CommonStatusFields Fields common to both ETH/68 and ETH/69 Status messages.
struct	eth::NewBlockHashEntry
struct	eth::NewBlockHashesMessage
struct	eth::NewPooledTransactionHashesMessage
struct	eth::GetBlockHeadersMessage
struct	eth::BlockHeadersMessage
struct	eth::GetReceiptsMessage
struct	eth::ReceiptsMessage
struct	eth::GetPooledTransactionsMessage
struct	eth::PooledTransactionsMessage
struct	eth::GetBlockBodiesMessage Request for block bodies by hash (message id 0x05).
struct	eth::BlockBody A single block body: transactions + ommers (uncle headers).
struct	eth::BlockBodiesMessage Response to GetBlockBodies (message id 0x06).
struct	eth::NewBlockMessage Full new block announcement (message id 0x07).

Types¶

	Name
enum class	StatusValidationError { kProtocolVersionMismatch, kNetworkIDMismatch, kGenesisMismatch, kInvalidBlockRange} Errors returned by validate_status(), mirroring go-ethereum's readStatus error values from eth/protocols/eth/handshake.go.
using rlp::Hash256	Hash256
using rlp::Address	Address
using rlp::Bloom	Bloom
using std::variant< StatusMessage68, StatusMessage69 >	StatusMessage Dual-version Status message (ETH/68 or ETH/69).

Functions¶

	Name
CommonStatusFields	get_common_fields(const StatusMessage & msg) Extract fields common to both ETH/68 and ETH/69 Status messages.

Attributes¶

	Name
uint8_t	kEthProtocolVersion66
uint8_t	kEthProtocolVersion67
uint8_t	kEthProtocolVersion68
uint8_t	kEthProtocolVersion69

Types Documentation¶

enum StatusValidationError¶

Enumerator	Value	Description
kProtocolVersionMismatch		status.ProtocolVersion != negotiated version
kNetworkIDMismatch		status.NetworkID != expected network ID
kGenesisMismatch		status.Genesis != our genesis hash
kInvalidBlockRange		status.EarliestBlock > status.LatestBlock

Errors returned by validate_status(), mirroring go-ethereum's readStatus error values from eth/protocols/eth/handshake.go.

using Hash256¶

using eth::Hash256 = rlp::Hash256;

using Address¶

using eth::Address = rlp::Address;

using Bloom¶

using eth::Bloom = rlp::Bloom;

using StatusMessage¶

using eth::StatusMessage = std::variant<StatusMessage68, StatusMessage69>;

Dual-version Status message (ETH/68 or ETH/69).

Functions Documentation¶

function get_common_fields¶

CommonStatusFields get_common_fields(
    const StatusMessage & msg
)

Extract fields common to both ETH/68 and ETH/69 Status messages.

Attributes Documentation¶

variable kEthProtocolVersion66¶

uint8_t kEthProtocolVersion66 = 66U;

variable kEthProtocolVersion67¶

uint8_t kEthProtocolVersion67 = 67U;

variable kEthProtocolVersion68¶

uint8_t kEthProtocolVersion68 = 68U;

variable kEthProtocolVersion69¶

uint8_t kEthProtocolVersion69 = 69U;

Source code¶

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

#pragma once

#include <array>
#include <cstdint>
#include <optional>
#include <variant>
#include <vector>
#include <rlp/intx.hpp>
#include <rlp/rlp_ethereum.hpp>
#include "objects.hpp"

namespace eth {

using Hash256 = rlp::Hash256;
using Address = rlp::Address;
using Bloom = rlp::Bloom;

inline constexpr uint8_t kEthProtocolVersion66 = 66U;
inline constexpr uint8_t kEthProtocolVersion67 = 67U;
inline constexpr uint8_t kEthProtocolVersion68 = 68U;
inline constexpr uint8_t kEthProtocolVersion69 = 69U;

struct ForkId {
    std::array<uint8_t, 4> fork_hash{};
    uint64_t next_fork = 0;
};

struct StatusMessage68
{
    uint8_t       protocol_version = kEthProtocolVersion68;
    uint64_t      network_id = 0;
    intx::uint256 td{};
    Hash256       blockhash{};
    Hash256       genesis_hash{};
    ForkId        fork_id{};
};

struct StatusMessage69
{
    uint8_t  protocol_version = kEthProtocolVersion69;
    uint64_t network_id = 0;
    Hash256  genesis_hash{};
    ForkId   fork_id{};
    uint64_t earliest_block = 0;
    uint64_t latest_block = 0;
    Hash256  latest_block_hash{};
};

struct CommonStatusFields
{
    uint8_t  protocol_version = 0;
    uint64_t network_id = 0;
    Hash256  genesis_hash{};
    ForkId   fork_id{};
};

using StatusMessage = std::variant<StatusMessage68, StatusMessage69>;

[[nodiscard]] CommonStatusFields get_common_fields(const StatusMessage& msg) noexcept;

enum class StatusValidationError {
    kProtocolVersionMismatch,  
    kNetworkIDMismatch,        
    kGenesisMismatch,          
    kInvalidBlockRange,        
};

struct NewBlockHashEntry {
    Hash256 hash{};
    uint64_t number = 0;
};

struct NewBlockHashesMessage {
    std::vector<NewBlockHashEntry> entries;
};

struct NewPooledTransactionHashesMessage {
    std::vector<Hash256> hashes;
};

struct GetBlockHeadersMessage {
    std::optional<uint64_t> request_id;
    std::optional<Hash256> start_hash;
    std::optional<uint64_t> start_number;
    uint64_t max_headers = 0;
    uint64_t skip = 0;
    bool reverse = false;
};

struct BlockHeadersMessage {
    std::optional<uint64_t> request_id;
    std::vector<codec::BlockHeader> headers;
};

struct GetReceiptsMessage {
    std::optional<uint64_t> request_id;
    std::vector<Hash256> block_hashes;
};

struct ReceiptsMessage {
    std::optional<uint64_t> request_id;
    std::vector<std::vector<codec::Receipt>> receipts;
};

struct GetPooledTransactionsMessage {
    std::optional<uint64_t> request_id;
    std::vector<Hash256> transaction_hashes;
};

struct PooledTransactionsMessage {
    std::optional<uint64_t> request_id;
    std::vector<std::vector<uint8_t>> encoded_transactions;
};

struct GetBlockBodiesMessage {
    std::optional<uint64_t> request_id;
    std::vector<Hash256> block_hashes;
};

struct BlockBody {
    std::vector<codec::Transaction> transactions;
    std::vector<codec::BlockHeader> ommers;
};

struct BlockBodiesMessage {
    std::optional<uint64_t> request_id;
    std::vector<BlockBody> bodies;
};

struct NewBlockMessage {
    codec::BlockHeader header;
    std::vector<codec::Transaction> transactions;
    std::vector<codec::BlockHeader> ommers;
    intx::uint256 total_difficulty{};
};

} // namespace eth

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