rlpx/rlpx_types.hpp¶

Namespaces¶

Name
rlpx
rlpx::detail

Classes¶

	Name
struct	rlpx::AesBlock RLPx wire structs — sizes are derived via sizeof() rather than magic numbers.
struct	rlpx::MacDigestWire 16-byte frame-level MAC digest (first 16 bytes of the running Keccak state).
struct	rlpx::FrameHeaderWire 16-byte RLPx frame header: 3-byte length

Types¶

	Name
enum class uint8_t	SessionState
enum class uint8_t	DisconnectReason
using std::array< uint8_t, kPublicKeySize >	PublicKey
using std::array< uint8_t, kPrivateKeySize >	PrivateKey
using std::array< uint8_t, kNonceSize >	Nonce
using std::array< uint8_t, kSharedSecretSize >	SharedSecret
using std::array< uint8_t, kAesKeySize >	AesKey
using std::array< uint8_t, kMacKeySize >	MacKey
using std::array< uint8_t, kMacSize >	MacDigest
using std::array< uint8_t, kFrameHeaderSize >	FrameHeader
using std::vector< uint8_t >	ByteBuffer
using gsl::span< const uint8_t >	ByteView
using gsl::span< uint8_t >	MutableByteView

Functions¶

	Name
rlp::ByteView	to_rlp_view(rlpx::ByteView view)
rlpx::ByteView	from_rlp_view(rlp::ByteView view)
rlp::Bytes	to_rlp_bytes(const rlpx::ByteBuffer & buffer)
rlpx::ByteBuffer	from_rlp_bytes(const rlp::Bytes & bytes)

Attributes¶

	Name
constexpr size_t	kPublicKeySize
constexpr size_t	kPrivateKeySize
constexpr size_t	kNonceSize
constexpr size_t	kSharedSecretSize
constexpr size_t	kAesKeySize
constexpr size_t	kMacKeySize
constexpr size_t	kUncompressedPubKeyPrefixSize Uncompressed secp256k1 public key: 0x04 prefix byte + 64 bytes = 65 bytes total.
constexpr size_t	kUncompressedPubKeySize
constexpr uint8_t	kUncompressedPubKeyPrefix
constexpr size_t	kHmacSha256Size HMAC-SHA256 full digest output size.
constexpr size_t	kAesBlockSize
constexpr size_t	kMacSize
constexpr size_t	kFrameHeaderSize
constexpr size_t	kEciesMacSize ECIES / EIP-8 wire constants.
constexpr size_t	kEciesOverheadSize
constexpr size_t	kEip8LengthPrefixSize
constexpr size_t	kEip8AuthPaddingSize
constexpr size_t	kMaxEip8HandshakePacketSize
constexpr size_t	kFrameLengthSize Number of bytes used to encode the frame length inside the frame header.
constexpr size_t	kFrameHeaderDataOffset
constexpr size_t	kFrameHeaderWithMacSize
constexpr size_t	kFramePaddingAlignment
constexpr size_t	kFrameLengthMsbOffset
constexpr size_t	kFrameLengthMiddleOffset
constexpr size_t	kFrameLengthLsbOffset
constexpr size_t	kFrameLengthMsbShift
constexpr size_t	kFrameLengthMiddleShift
constexpr size_t	kFrameLengthLsbShift
constexpr std::array< uint8_t, kFrameLengthSize >	kFrameHeaderStaticRlpBytes
constexpr size_t	kEcdsaCompactSigSize
constexpr size_t	kEcdsaRecoveryIdSize
constexpr size_t	kEcdsaSigSize
constexpr size_t	kAuthVersionSize Version byte appended to auth/ack messages (RLPx v4 EIP-8).
constexpr uint8_t	kAuthVersion
constexpr size_t	kMaxFrameSizeMiB Maximum RLPx frame payload: 16 MiB.
constexpr size_t	kMaxFrameSize
constexpr uint8_t	kHelloMessageId
constexpr uint8_t	kDisconnectMessageId
constexpr uint8_t	kPingMessageId
constexpr uint8_t	kPongMessageId
constexpr uint8_t	kProtocolVersion
constexpr auto	kTcpConnectionTimeout
constexpr auto	kProtocolHandshakeTimeout
constexpr auto	kSendLoopPollInterval

Types Documentation¶

enum SessionState¶

Enumerator	Value	Description
kUninitialized	0
kConnecting
kAuthenticating
kHandshaking
kActive
kDisconnecting
kClosed
kError

enum DisconnectReason¶

Enumerator	Value	Description
kRequested	0x00
kTcpError	0x01
kProtocolError	0x02
kUselessPeer	0x03
kTooManyPeers	0x04
kAlreadyConnected	0x05
kIncompatibleVersion	0x06
kInvalidIdentity	0x07
kClientQuitting	0x08
kUnexpectedIdentity	0x09
kSelfConnection	0x0A
kTimeout	0x0B
kSubprotocolError	0x10

using PublicKey¶

using rlpx::PublicKey = typedef std::array<uint8_t, kPublicKeySize>;

using PrivateKey¶

using rlpx::PrivateKey = typedef std::array<uint8_t, kPrivateKeySize>;

using Nonce¶

using rlpx::Nonce = typedef std::array<uint8_t, kNonceSize>;

using SharedSecret¶

using rlpx::SharedSecret = typedef std::array<uint8_t, kSharedSecretSize>;

using AesKey¶

using rlpx::AesKey = typedef std::array<uint8_t, kAesKeySize>;

using MacKey¶

using rlpx::MacKey = typedef std::array<uint8_t, kMacKeySize>;

using MacDigest¶

using rlpx::MacDigest = typedef std::array<uint8_t, kMacSize>;

using FrameHeader¶

using rlpx::FrameHeader = typedef std::array<uint8_t, kFrameHeaderSize>;

using ByteBuffer¶

using rlpx::ByteBuffer = typedef std::vector<uint8_t>;

using ByteView¶

using rlpx::ByteView = typedef gsl::span<const uint8_t>;

using MutableByteView¶

using rlpx::MutableByteView = typedef gsl::span<uint8_t>;

Functions Documentation¶

function to_rlp_view¶

inline rlp::ByteView to_rlp_view(
    rlpx::ByteView view
)

function from_rlp_view¶

inline rlpx::ByteView from_rlp_view(
    rlp::ByteView view
)

function to_rlp_bytes¶

inline rlp::Bytes to_rlp_bytes(
    const rlpx::ByteBuffer & buffer
)

function from_rlp_bytes¶

inline rlpx::ByteBuffer from_rlp_bytes(
    const rlp::Bytes & bytes
)

Attributes Documentation¶

variable kPublicKeySize¶

constexpr size_t kPublicKeySize = 64;

variable kPrivateKeySize¶

constexpr size_t kPrivateKeySize = 32;

variable kNonceSize¶

constexpr size_t kNonceSize = 32;

variable kSharedSecretSize¶

constexpr size_t kSharedSecretSize = 32;

variable kAesKeySize¶

constexpr size_t kAesKeySize = 32;

variable kMacKeySize¶

constexpr size_t kMacKeySize = 32;

variable kUncompressedPubKeyPrefixSize¶

constexpr size_t kUncompressedPubKeyPrefixSize = 1;

Uncompressed secp256k1 public key: 0x04 prefix byte + 64 bytes = 65 bytes total.

The single 0x04 prefix byte

variable kUncompressedPubKeySize¶

constexpr size_t kUncompressedPubKeySize = kPublicKeySize + kUncompressedPubKeyPrefixSize;

variable kUncompressedPubKeyPrefix¶

constexpr uint8_t kUncompressedPubKeyPrefix = 0x04U;

variable kHmacSha256Size¶

constexpr size_t kHmacSha256Size = 32;

HMAC-SHA256 full digest output size.

variable kAesBlockSize¶

constexpr size_t kAesBlockSize = sizeof(AesBlock);

variable kMacSize¶

constexpr size_t kMacSize = sizeof(MacDigestWire);

variable kFrameHeaderSize¶

constexpr size_t kFrameHeaderSize = sizeof(FrameHeaderWire);

variable kEciesMacSize¶

constexpr size_t kEciesMacSize = kHmacSha256Size;

ECIES / EIP-8 wire constants.

variable kEciesOverheadSize¶

constexpr size_t kEciesOverheadSize = kUncompressedPubKeySize + kAesBlockSize + kEciesMacSize;

variable kEip8LengthPrefixSize¶

constexpr size_t kEip8LengthPrefixSize = sizeof(uint16_t);

variable kEip8AuthPaddingSize¶

constexpr size_t kEip8AuthPaddingSize = 100;

variable kMaxEip8HandshakePacketSize¶

constexpr size_t kMaxEip8HandshakePacketSize = 2048U;

variable kFrameLengthSize¶

constexpr size_t kFrameLengthSize = 3;

Number of bytes used to encode the frame length inside the frame header.

variable kFrameHeaderDataOffset¶

constexpr size_t kFrameHeaderDataOffset = kFrameLengthSize;

variable kFrameHeaderWithMacSize¶

constexpr size_t kFrameHeaderWithMacSize = kFrameHeaderSize + kMacSize;

variable kFramePaddingAlignment¶

constexpr size_t kFramePaddingAlignment = kAesBlockSize;

variable kFrameLengthMsbOffset¶

constexpr size_t kFrameLengthMsbOffset = 0;

variable kFrameLengthMiddleOffset¶

constexpr size_t kFrameLengthMiddleOffset = 1;

variable kFrameLengthLsbOffset¶

constexpr size_t kFrameLengthLsbOffset = 2;

variable kFrameLengthMsbShift¶

constexpr size_t kFrameLengthMsbShift = 16U;

variable kFrameLengthMiddleShift¶

constexpr size_t kFrameLengthMiddleShift = 8U;

variable kFrameLengthLsbShift¶

constexpr size_t kFrameLengthLsbShift = 0U;

variable kFrameHeaderStaticRlpBytes¶

constexpr std::array< uint8_t, kFrameLengthSize > kFrameHeaderStaticRlpBytes = { 0xC2U, 0x80U, 0x80U };

variable kEcdsaCompactSigSize¶

constexpr size_t kEcdsaCompactSigSize = 64;

RLPx auth message wire constants Recoverable ECDSA compact signature: 64 bytes data + 1 byte recovery id.

variable kEcdsaRecoveryIdSize¶

constexpr size_t kEcdsaRecoveryIdSize = 1;

variable kEcdsaSigSize¶

constexpr size_t kEcdsaSigSize = kEcdsaCompactSigSize + kEcdsaRecoveryIdSize;

variable kAuthVersionSize¶

constexpr size_t kAuthVersionSize = 1;

Version byte appended to auth/ack messages (RLPx v4 EIP-8).

variable kAuthVersion¶

constexpr uint8_t kAuthVersion = 4U;

variable kMaxFrameSizeMiB¶

constexpr size_t kMaxFrameSizeMiB = 16;

Maximum RLPx frame payload: 16 MiB.

variable kMaxFrameSize¶

constexpr size_t kMaxFrameSize = kMaxFrameSizeMiB * 1024 * 1024;

variable kHelloMessageId¶

constexpr uint8_t kHelloMessageId = 0x00;

variable kDisconnectMessageId¶

constexpr uint8_t kDisconnectMessageId = 0x01;

variable kPingMessageId¶

constexpr uint8_t kPingMessageId = 0x02;

variable kPongMessageId¶

constexpr uint8_t kPongMessageId = 0x03;

variable kProtocolVersion¶

constexpr uint8_t kProtocolVersion = 5;

variable kTcpConnectionTimeout¶

constexpr auto kTcpConnectionTimeout = std::chrono::seconds(10);

variable kProtocolHandshakeTimeout¶

constexpr auto kProtocolHandshakeTimeout = std::chrono::seconds(5);

variable kSendLoopPollInterval¶

constexpr auto kSendLoopPollInterval = std::chrono::milliseconds(10);

Source code¶

// Copyright 2026 Genius Ventures, Inc.
// SPDX-License-Identifier: MIT

#ifndef EVMRELAY_INCLUDE_RLPX_RLPX_TYPES_HPP
#define EVMRELAY_INCLUDE_RLPX_RLPX_TYPES_HPP

#include <array>
#include <chrono>
#include <cstdint>
#include <string_view>
#include <vector>
#include <optional>
#include <gsl/span>
#include <rlp/common.hpp>  // For rlp::Bytes and rlp::ByteView types

namespace rlpx {

// Constant sizes — expressed as sizeof() on wire structs where possible
inline constexpr size_t kPublicKeySize    = 64;
inline constexpr size_t kPrivateKeySize   = 32;
inline constexpr size_t kNonceSize        = 32;
inline constexpr size_t kSharedSecretSize = 32;
inline constexpr size_t kAesKeySize       = 32;
inline constexpr size_t kMacKeySize       = 32;

inline constexpr size_t  kUncompressedPubKeyPrefixSize = 1;  
inline constexpr size_t  kUncompressedPubKeySize       = kPublicKeySize + kUncompressedPubKeyPrefixSize;
inline constexpr uint8_t kUncompressedPubKeyPrefix     = 0x04U;

inline constexpr size_t kHmacSha256Size = 32;


struct AesBlock    { uint8_t bytes[16]; };

struct MacDigestWire { uint8_t bytes[16]; };

struct FrameHeaderWire { uint8_t bytes[16]; };

inline constexpr size_t kAesBlockSize    = sizeof(AesBlock);
inline constexpr size_t kMacSize         = sizeof(MacDigestWire);
inline constexpr size_t kFrameHeaderSize = sizeof(FrameHeaderWire);

inline constexpr size_t kEciesMacSize          = kHmacSha256Size;
inline constexpr size_t kEciesOverheadSize     = kUncompressedPubKeySize + kAesBlockSize + kEciesMacSize;
inline constexpr size_t kEip8LengthPrefixSize  = sizeof(uint16_t);
inline constexpr size_t kEip8AuthPaddingSize   = 100;
inline constexpr size_t kMaxEip8HandshakePacketSize = 2048U;

inline constexpr size_t kFrameLengthSize = 3;
inline constexpr size_t kFrameHeaderDataOffset   = kFrameLengthSize;
inline constexpr size_t kFrameHeaderWithMacSize  = kFrameHeaderSize + kMacSize;
inline constexpr size_t kFramePaddingAlignment   = kAesBlockSize;
inline constexpr size_t kFrameLengthMsbOffset    = 0;
inline constexpr size_t kFrameLengthMiddleOffset = 1;
inline constexpr size_t kFrameLengthLsbOffset    = 2;
inline constexpr size_t kFrameLengthMsbShift     = 16U;
inline constexpr size_t kFrameLengthMiddleShift  = 8U;
inline constexpr size_t kFrameLengthLsbShift     = 0U;
inline constexpr std::array<uint8_t, kFrameLengthSize> kFrameHeaderStaticRlpBytes = { 0xC2U, 0x80U, 0x80U };

inline constexpr size_t kEcdsaCompactSigSize = 64;
inline constexpr size_t kEcdsaRecoveryIdSize = 1;
inline constexpr size_t kEcdsaSigSize        = kEcdsaCompactSigSize + kEcdsaRecoveryIdSize;

inline constexpr size_t  kAuthVersionSize    = 1;
inline constexpr uint8_t kAuthVersion        = 4U;

inline constexpr size_t kMaxFrameSizeMiB = 16;
inline constexpr size_t kMaxFrameSize    = kMaxFrameSizeMiB * 1024 * 1024;

// Type aliases for better semantics
using PublicKey    = std::array<uint8_t, kPublicKeySize>;
using PrivateKey   = std::array<uint8_t, kPrivateKeySize>;
using Nonce        = std::array<uint8_t, kNonceSize>;
using SharedSecret = std::array<uint8_t, kSharedSecretSize>;
using AesKey       = std::array<uint8_t, kAesKeySize>;
using MacKey       = std::array<uint8_t, kMacKeySize>;
using MacDigest    = std::array<uint8_t, kMacSize>;
using FrameHeader  = std::array<uint8_t, kFrameHeaderSize>;

// Hide implementation details behind type aliases (Law of Demeter)
using ByteBuffer = std::vector<uint8_t>;
using ByteView = gsl::span<const uint8_t>;
using MutableByteView = gsl::span<uint8_t>;

// Session state enum
enum class SessionState : uint8_t {
    kUninitialized = 0,
    kConnecting,
    kAuthenticating,
    kHandshaking,
    kActive,
    kDisconnecting,
    kClosed,
    kError
};

// Disconnect reasons (from RLPx spec)
enum class DisconnectReason : uint8_t {
    kRequested = 0x00,
    kTcpError = 0x01,
    kProtocolError = 0x02,
    kUselessPeer = 0x03,
    kTooManyPeers = 0x04,
    kAlreadyConnected = 0x05,
    kIncompatibleVersion = 0x06,
    kInvalidIdentity = 0x07,
    kClientQuitting = 0x08,
    kUnexpectedIdentity = 0x09,
    kSelfConnection = 0x0A,
    kTimeout = 0x0B,
    kSubprotocolError = 0x10
};

// Protocol message IDs
inline constexpr uint8_t kHelloMessageId = 0x00;
inline constexpr uint8_t kDisconnectMessageId = 0x01;
inline constexpr uint8_t kPingMessageId = 0x02;
inline constexpr uint8_t kPongMessageId = 0x03;

// Protocol version
inline constexpr uint8_t kProtocolVersion = 5;

// Timing constants
inline constexpr auto kTcpConnectionTimeout  = std::chrono::seconds(10);
inline constexpr auto kProtocolHandshakeTimeout = std::chrono::seconds(5);
inline constexpr auto kSendLoopPollInterval  = std::chrono::milliseconds(10);

// Conversion functions for interop with rlp library
namespace detail {    
    // Convert rlpx::ByteView (gsl::span) to rlp::ByteView (std::basic_string_view)
    inline rlp::ByteView to_rlp_view(rlpx::ByteView view) noexcept {
        return rlp::ByteView(view.data(), view.size());
    }

    // Convert rlp::ByteView to rlpx::ByteView
    inline rlpx::ByteView from_rlp_view(rlp::ByteView view) noexcept {
        return rlpx::ByteView(view.data(), view.size());
    }

    // Convert rlpx::ByteBuffer to rlp::Bytes
    inline rlp::Bytes to_rlp_bytes(const rlpx::ByteBuffer& buffer) {
        return rlp::Bytes(buffer.begin(), buffer.end());
    }

    // Convert rlp::Bytes to rlpx::ByteBuffer
    inline rlpx::ByteBuffer from_rlp_bytes(const rlp::Bytes& bytes) {
        return rlpx::ByteBuffer(bytes.begin(), bytes.end());
    }
}

} // namespace rlpx

#endif // EVMRELAY_INCLUDE_RLPX_RLPX_TYPES_HPP

Updated on 2026-08-06 at 13:59:18 +0000