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::EthMessageFieldSchema
struct	eth::EthMessageSchema
struct	eth::NewBlockHashEntry
struct	eth::NewBlockHashesMessage
struct	eth::NewPooledTransactionHashesMessage
struct	eth::BlockRangeUpdateMessage
struct	eth::UpgradeStatusMessage
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	EthMessageFieldType
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 EthMessageFieldType¶

Enumerator	Value	Description
kUint8
kUint16
kUint32
kUint64
kUint256
kHash32
kHash4
kForkId
kBytes
kBool
kHashOrNumber
kHashList
kUintList
kUint32List
kBytesList
kBlockHashEntries
kGetBlockHeadersQuery
kBlockHeaders
kBlockBodies
kBlock
kTransactions
kReceipts
kPooledTransactions

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 2026 Genius Ventures, Inc.
// SPDX-License-Identifier: MIT

#ifndef EVMRELAY_INCLUDE_ETH_ETH_TYPES_HPP
#define EVMRELAY_INCLUDE_ETH_ETH_TYPES_HPP

#include <array>
#include <cstdint>
#include <optional>
#include <string>
#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 EthMessageFieldType
{
    kUint8,
    kUint16,
    kUint32,
    kUint64,
    kUint256,
    kHash32,
    kHash4,
    kForkId,
    kBytes,
    kBool,
    kHashOrNumber,
    kHashList,
    kUintList,
    kUint32List,
    kBytesList,
    kBlockHashEntries,
    kGetBlockHeadersQuery,
    kBlockHeaders,
    kBlockBodies,
    kBlock,
    kTransactions,
    kReceipts,
    kPooledTransactions
};

struct EthMessageFieldSchema
{
    std::string         name;
    EthMessageFieldType type = EthMessageFieldType::kBytes;
    std::optional<size_t> size;
    std::optional<size_t> offset;
};

struct EthMessageSchema
{
    std::string                        name;
    uint8_t                            message_id = 0;
    std::optional<uint8_t>             protocol_version;
    std::vector<EthMessageFieldSchema> fields;
};

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<uint8_t> types;
    std::vector<uint32_t> sizes;
    std::vector<Hash256> hashes;
};

struct BlockRangeUpdateMessage {
    uint64_t earliest_block = 0;
    uint64_t latest_block = 0;
    Hash256 latest_block_hash{};
};

struct UpgradeStatusMessage {
    bool disable_peer_tx_broadcast = false;
};

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


#endif // EVMRELAY_INCLUDE_ETH_ETH_TYPES_HPP

Updated on 2026-06-05 at 17:22:19 -0700