rlpx¶

Namespaces¶

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

Classes¶

	Name
struct	rlpx::SessionConnectParams
struct	rlpx::SessionAcceptParams
struct	rlpx::PeerInfo
class	rlpx::RlpxSession RLPx session managing encrypted P2P communication.
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	SessionError
enum class	AuthError
enum class	FramingError
enum class	CryptoError
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::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
size_t	kPublicKeySize
size_t	kPrivateKeySize
size_t	kNonceSize
size_t	kSharedSecretSize
size_t	kAesKeySize
size_t	kMacKeySize
size_t	kUncompressedPubKeyPrefixSize Uncompressed secp256k1 public key: 0x04 prefix byte + 64 bytes = 65 bytes total.
size_t	kUncompressedPubKeySize
uint8_t	kUncompressedPubKeyPrefix
size_t	kHmacSha256Size HMAC-SHA256 full digest output size.
size_t	kAesBlockSize
size_t	kMacSize
size_t	kFrameHeaderSize
size_t	kEciesMacSize ECIES / EIP-8 wire constants.
size_t	kEciesOverheadSize
size_t	kEip8LengthPrefixSize
size_t	kEip8AuthPaddingSize
size_t	kMaxEip8HandshakePacketSize
size_t	kFrameLengthSize Number of bytes used to encode the frame length inside the frame header.
size_t	kFrameHeaderDataOffset
size_t	kFrameHeaderWithMacSize
size_t	kFramePaddingAlignment
size_t	kFrameLengthMsbOffset
size_t	kFrameLengthMiddleOffset
size_t	kFrameLengthLsbOffset
size_t	kFrameLengthMsbShift
size_t	kFrameLengthMiddleShift
size_t	kFrameLengthLsbShift
std::array< uint8_t, kFrameLengthSize >	kFrameHeaderStaticRlpBytes
size_t	kEcdsaCompactSigSize
size_t	kEcdsaRecoveryIdSize
size_t	kEcdsaSigSize
size_t	kAuthVersionSize Version byte appended to auth/ack messages (RLPx v4 EIP-8).
uint8_t	kAuthVersion
size_t	kMaxFrameSizeMiB Maximum RLPx frame payload: 16 MiB.
size_t	kMaxFrameSize
uint8_t	kHelloMessageId
uint8_t	kDisconnectMessageId
uint8_t	kPingMessageId
uint8_t	kPongMessageId
uint8_t	kProtocolVersion
auto	kTcpConnectionTimeout
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 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 = asio::ip::tcp;

using Result¶

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

using AuthResult¶

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

using FramingResult¶

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

using CryptoResult¶

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

using VoidResult¶

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

using AuthVoidResult¶

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

using FramingVoidResult¶

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

using CryptoVoidResult¶

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

using MessageHandler¶

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

using HelloHandler¶

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

using DisconnectHandler¶

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

using PingHandler¶

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

using PongHandler¶

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

using PublicKey¶

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

using PrivateKey¶

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

using Nonce¶

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

using SharedSecret¶

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

using AesKey¶

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

using MacKey¶

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

using MacDigest¶

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

using FrameHeader¶

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

using ByteBuffer¶

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

using ByteView¶

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

using MutableByteView¶

using rlpx::MutableByteView = 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¶

size_t kPublicKeySize = 64;

variable kPrivateKeySize¶

size_t kPrivateKeySize = 32;

variable kNonceSize¶

size_t kNonceSize = 32;

variable kSharedSecretSize¶

size_t kSharedSecretSize = 32;

variable kAesKeySize¶

size_t kAesKeySize = 32;

variable kMacKeySize¶

size_t kMacKeySize = 32;

variable kUncompressedPubKeyPrefixSize¶

size_t kUncompressedPubKeyPrefixSize = 1;

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

The single 0x04 prefix byte

variable kUncompressedPubKeySize¶

size_t kUncompressedPubKeySize = kPublicKeySize + kUncompressedPubKeyPrefixSize;

variable kUncompressedPubKeyPrefix¶

uint8_t kUncompressedPubKeyPrefix = 0x04U;

variable kHmacSha256Size¶

size_t kHmacSha256Size = 32;

HMAC-SHA256 full digest output size.

variable kAesBlockSize¶

size_t kAesBlockSize = sizeof(AesBlock);

variable kMacSize¶

size_t kMacSize = sizeof(MacDigestWire);

variable kFrameHeaderSize¶

size_t kFrameHeaderSize = sizeof(FrameHeaderWire);

variable kEciesMacSize¶

size_t kEciesMacSize = kHmacSha256Size;

ECIES / EIP-8 wire constants.

variable kEciesOverheadSize¶

size_t kEciesOverheadSize = kUncompressedPubKeySize + kAesBlockSize + kEciesMacSize;

variable kEip8LengthPrefixSize¶

size_t kEip8LengthPrefixSize = sizeof(uint16_t);

variable kEip8AuthPaddingSize¶

size_t kEip8AuthPaddingSize = 100;

variable kMaxEip8HandshakePacketSize¶

size_t kMaxEip8HandshakePacketSize = 2048U;

variable kFrameLengthSize¶

size_t kFrameLengthSize = 3;

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

variable kFrameHeaderDataOffset¶

size_t kFrameHeaderDataOffset = kFrameLengthSize;

variable kFrameHeaderWithMacSize¶

size_t kFrameHeaderWithMacSize = kFrameHeaderSize + kMacSize;

variable kFramePaddingAlignment¶

size_t kFramePaddingAlignment = kAesBlockSize;

variable kFrameLengthMsbOffset¶

size_t kFrameLengthMsbOffset = 0;

variable kFrameLengthMiddleOffset¶

size_t kFrameLengthMiddleOffset = 1;

variable kFrameLengthLsbOffset¶

size_t kFrameLengthLsbOffset = 2;

variable kFrameLengthMsbShift¶

size_t kFrameLengthMsbShift = 16U;

variable kFrameLengthMiddleShift¶

size_t kFrameLengthMiddleShift = 8U;

variable kFrameLengthLsbShift¶

size_t kFrameLengthLsbShift = 0U;

variable kFrameHeaderStaticRlpBytes¶

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

variable kEcdsaCompactSigSize¶

size_t kEcdsaCompactSigSize = 64;

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

variable kEcdsaRecoveryIdSize¶

size_t kEcdsaRecoveryIdSize = 1;

variable kEcdsaSigSize¶

size_t kEcdsaSigSize = kEcdsaCompactSigSize + kEcdsaRecoveryIdSize;

variable kAuthVersionSize¶

size_t kAuthVersionSize = 1;

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

variable kAuthVersion¶

uint8_t kAuthVersion = 4U;

variable kMaxFrameSizeMiB¶

size_t kMaxFrameSizeMiB = 16;

Maximum RLPx frame payload: 16 MiB.

variable kMaxFrameSize¶

size_t kMaxFrameSize = kMaxFrameSizeMiB * 1024 * 1024;

variable kHelloMessageId¶

uint8_t kHelloMessageId = 0x00;

variable kDisconnectMessageId¶

uint8_t kDisconnectMessageId = 0x01;

variable kPingMessageId¶

uint8_t kPingMessageId = 0x02;

variable kPongMessageId¶

uint8_t kPongMessageId = 0x03;

variable kProtocolVersion¶

uint8_t kProtocolVersion = 5;

variable kTcpConnectionTimeout¶

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

variable kSendLoopPollInterval¶

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

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