rlpx¶

Namespaces¶

Name
rlpx::auth
rlpx::crypto
rlpx::detail
rlpx::framing
rlpx::protocol
rlpx::socket

Classes¶

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

Types¶

	Name
enum class	SessionError
enum class	AuthError
enum class	FramingError
enum class	CryptoError
enum class uint8_t	ConnectProgressPhase
enum class uint8_t	SessionState
enum class uint8_t	DisconnectReason
using asio::ip::tcp	tcp
template <typename T > using outcome::result< T, SessionError, outcome::policy::all_narrow >	Result
template <typename T > using outcome::result< T, AuthError, outcome::policy::all_narrow >	AuthResult
template <typename T > using outcome::result< T, FramingError, outcome::policy::all_narrow >	FramingResult
template <typename T > using outcome::result< T, CryptoError, outcome::policy::all_narrow >	CryptoResult
using outcome::result< void, SessionError, outcome::policy::all_narrow >	VoidResult
using outcome::result< void, AuthError, outcome::policy::all_narrow >	AuthVoidResult
using outcome::result< void, FramingError, outcome::policy::all_narrow >	FramingVoidResult
using outcome::result< void, CryptoError, outcome::policy::all_narrow >	CryptoVoidResult
using std::function< void(const protocol::Message &)>	MessageHandler
using std::function< void(const protocol::HelloMessage &)>	HelloHandler
using std::function< void(const protocol::DisconnectMessage &)>	DisconnectHandler
using std::function< void(const protocol::PingMessage &)>	PingHandler
using std::function< void(const protocol::PongMessage &)>	PongHandler
using std::function< void(uint8_t, const ByteBuffer &)>	EthMessageHandler
using std::function< void(ConnectProgressPhase, DisconnectReason)>	ConnectProgressHandler
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
const char *	to_string(SessionError error)
const char *	to_string(AuthError error)
const char *	to_string(FramingError error)
const char *	to_string(CryptoError error)

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 SessionError¶

Enumerator	Value	Description
kNetworkFailure
kAuthenticationFailed
kHandshakeFailed
kInvalidState
kPeerDisconnected
kTimeout
kCompressionError
kEncryptionError
kDecryptionError
kInvalidMessage
kInvalidFrameSize
kBufferOverflow
kConnectionFailed
kNotConnected
kDisconnected

enum AuthError¶

Enumerator	Value	Description
kEciesEncryptFailed
kEciesDecryptFailed
kInvalidAuthMessage
kInvalidAckMessage
kSharedSecretFailed
kSignatureInvalid
kKeyDerivationFailed
kInvalidPublicKey
kInvalidNonce

enum FramingError¶

Enumerator	Value	Description
kEncryptionFailed
kDecryptionFailed
kMacMismatch
kInvalidFrameSize
kBufferTooSmall
kInvalidHeader
kCompressionFailed
kDecompressionFailed

enum CryptoError¶

Enumerator	Value	Description
kAesEncryptFailed
kAesDecryptFailed
kHmacFailed
kKdfFailed
kEcdhFailed
kInvalidKeySize
kInvalidIvSize
kInvalidPublicKey
kInvalidPrivateKey
kOpenSslError
kSecp256k1Error

enum ConnectProgressPhase¶

Enumerator	Value	Description
kTcpConnected
kAuthSucceeded
kLocalHelloSent
kPeerDisconnectBeforeHello
kPeerHelloAccepted

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 tcp¶

using rlpx::tcp = typedef asio::ip::tcp;

using Result¶

template <typename T >
using rlpx::Result = typedef outcome::result<T, SessionError, outcome::policy::all_narrow>;

using AuthResult¶

template <typename T >
using rlpx::AuthResult = typedef outcome::result<T, AuthError, outcome::policy::all_narrow>;

using FramingResult¶

template <typename T >
using rlpx::FramingResult = typedef outcome::result<T, FramingError, outcome::policy::all_narrow>;

using CryptoResult¶

template <typename T >
using rlpx::CryptoResult = typedef outcome::result<T, CryptoError, outcome::policy::all_narrow>;

using VoidResult¶

using rlpx::VoidResult = typedef outcome::result<void, SessionError, outcome::policy::all_narrow>;

using AuthVoidResult¶

using rlpx::AuthVoidResult = typedef outcome::result<void, AuthError, outcome::policy::all_narrow>;

using FramingVoidResult¶

using rlpx::FramingVoidResult = typedef outcome::result<void, FramingError, outcome::policy::all_narrow>;

using CryptoVoidResult¶

using rlpx::CryptoVoidResult = typedef outcome::result<void, CryptoError, outcome::policy::all_narrow>;

using MessageHandler¶

using rlpx::MessageHandler = typedef std::function<void(const protocol::Message&)>;

using HelloHandler¶

using rlpx::HelloHandler = typedef std::function<void(const protocol::HelloMessage&)>;

using DisconnectHandler¶

using rlpx::DisconnectHandler = typedef std::function<void(const protocol::DisconnectMessage&)>;

using PingHandler¶

using rlpx::PingHandler = typedef std::function<void(const protocol::PingMessage&)>;

using PongHandler¶

using rlpx::PongHandler = typedef std::function<void(const protocol::PongMessage&)>;

using EthMessageHandler¶

using rlpx::EthMessageHandler = typedef std::function<void(uint8_t, const ByteBuffer&)>;

using ConnectProgressHandler¶

using rlpx::ConnectProgressHandler = typedef std::function<void(ConnectProgressPhase, DisconnectReason)>;

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_string¶

const char * to_string(
    SessionError error
)

function to_string¶

const char * to_string(
    AuthError error
)

function to_string¶

const char * to_string(
    FramingError error
)

function to_string¶

const char * to_string(
    CryptoError error
)

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);

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