Enum nostr_types::RelayMessageV4

pub enum RelayMessageV4 {
    Auth(String),
    Closed(SubscriptionId, String),
    Eose(SubscriptionId),
    Event(SubscriptionId, Box<EventV3>),
    Notice(String),
    Ok(Id, bool, String),
}

A message from a relay to a client

Variants

Auth(String)

Used to send authentication challenges

Closed(SubscriptionId, String)

Used to indicate that a subscription was ended on the server side Every ClientMessage::Req may trigger a RelayMessage::Closed response The last parameter may have a colon-terminated machine-readable prefix of: duplicate, pow, blocked, rate-limited, invalid, auth-required, restricted, or error

Eose(SubscriptionId)

End of subscribed events notification

Event(SubscriptionId, Box<EventV3>)

An event matching a subscription

Notice(String)

A human readable notice for errors and other information

Ok(Id, bool, String)

Used to notify clients if an event was successuful Every ClientMessage::Event will trigger a RelayMessage::OK response The last parameter may have a colon-terminated machine-readable prefix of: duplicate, pow, blocked, rate-limited, invalid, auth-required, restricted or error

Implementations

impl RelayMessageV4

pub fn why(&self) -> Option<Why>

Translate the machine-readable prefix from the message

Trait Implementations

impl Clone for RelayMessageV4

fn clone(&self) -> RelayMessageV4

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RelayMessageV4

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RelayMessageV4

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RelayMessageV4

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a_, C_: Context> Readable<'a_, C_> for RelayMessageV4

fn read_from<R_: Reader<'a_, C_>>(_reader_: &mut R_) -> Result<Self, C_::Error>

fn minimum_bytes_needed() -> usize

fn read_from_buffer_with_ctx( context: C, buffer: &'a [u8] ) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_with_ctx( context: C, buffer: &'a [u8] ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8] ) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8] ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_with_length_from_buffer_copying_data_with_ctx_mut( context: &mut C, buffer: &[u8] ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_stream_unbuffered_with_ctx<S>( context: C, stream: S ) -> Result<Self, <C as Context>::Error>

where S: Read,

fn read_from_stream_buffered_with_ctx<S>( context: C, stream: S ) -> Result<Self, <C as Context>::Error>

where S: Read,

fn read_from_file_with_ctx( context: C, path: impl AsRef<Path> ) -> Result<Self, <C as Context>::Error>

impl Serialize for RelayMessageV4

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<C_: Context> Writable<C_> for RelayMessageV4

fn write_to<T_: ?Sized + Writer<C_>>( &self, _writer_: &mut T_ ) -> Result<(), C_::Error>

fn write_to_buffer_with_ctx( &self, context: C, buffer: &mut [u8] ) -> Result<(), <C as Context>::Error>

fn write_to_buffer_with_ctx_mut( &self, context: &mut C, buffer: &mut [u8] ) -> Result<(), <C as Context>::Error>

fn write_to_vec_with_ctx( &self, context: C ) -> Result<Vec<u8>, <C as Context>::Error>

fn write_to_vec_with_ctx_mut( &self, context: &mut C ) -> Result<Vec<u8>, <C as Context>::Error>

fn write_to_stream_with_ctx<S>( &self, context: C, stream: S ) -> Result<(), <C as Context>::Error>

where S: Write,

fn write_to_file_with_ctx( &self, context: C, path: impl AsRef<Path> ) -> Result<(), <C as Context>::Error>

fn bytes_needed(&self) -> Result<usize, <C as Context>::Error>

impl Eq for RelayMessageV4

impl StructuralPartialEq for RelayMessageV4