Enum P2PMessage

pub enum P2PMessage {
    Hello(HelloMessage),
    Disconnect(DisconnectReason),
    Ping,
    Pong,
}

This represents only the reserved p2p subprotocol messages.

Variants

Hello(HelloMessage)

The first packet sent over the connection, and sent once by both sides.

Disconnect(DisconnectReason)

Inform the peer that a disconnection is imminent; if received, a peer should disconnect immediately.

Ping

Requests an immediate reply of P2PMessage::Pong from the peer.

Pong

Reply to the peer’s P2PMessage::Ping packet.

Implementations

impl P2PMessage

pub const fn message_id(&self) -> P2PMessageID

Gets the P2PMessageID for the given message.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for P2PMessage

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for P2PMessage

fn clone(&self) -> P2PMessage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for P2PMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decodable for P2PMessage

fn decode(buf: &mut &[u8]) -> Result<Self>

The [Decodable] implementation for P2PMessage assumes that each of the message variants are snappy compressed, except for the P2PMessage::Hello variant since the hello message is never compressed in the p2p subprotocol.

The [Decodable] implementation for P2PMessage::Ping and P2PMessage::Pong expects a snappy encoded payload, see [Encodable] implementation.

impl<'de> Deserialize<'de> for P2PMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for P2PMessage

fn encode(&self, out: &mut dyn BufMut)

The [Encodable] implementation for P2PMessage::Ping and P2PMessage::Pong encodes the message as RLP, and prepends a snappy header to the RLP bytes for all variants except the P2PMessage::Hello variant, because the hello message is never compressed in the p2p subprotocol.

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

impl From<P2PMessage> for P2PMessageID

fn from(msg: P2PMessage) -> Self

Converts to this type from the input type.

impl PartialEq for P2PMessage

fn eq(&self, other: &P2PMessage) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for P2PMessage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for P2PMessage

impl StructuralPartialEq for P2PMessage

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 120 bytes

Size for each variant:

• Hello: 120 bytes
• Disconnect: 9 bytes
• Ping: 0 bytes
• Pong: 0 bytes