Struct EventV1

pub struct EventV1 {
    pub id: Id,
    pub pubkey: PublicKey,
    pub created_at: Unixtime,
    pub kind: EventKind,
    pub sig: Signature,
    pub ots: Option<String>,
    pub content: String,
    pub tags: Vec<TagV1>,
}

The main event type

Fields

id: Id

The Id of the event, generated as a SHA256 of the inner event data

pubkey: PublicKey

The public key of the actor who created the event

created_at: Unixtime

The (unverified) time at which the event was created

kind: EventKind

The kind of event

sig: Signature

The signature of the event, which cryptographically verifies that the holder of the PrivateKey matching the event’s PublicKey generated (or authorized) this event. The signature is taken over the id field only, but the id field is taken over the rest of the event data.

ots: Option<String>

DEPRECATED (please set to Null): An optional verified time for the event (using OpenTimestamp)

content: String

The content of the event

tags: Vec<TagV1>

A set of tags that apply to the event

Implementations

impl EventV1

pub fn verify(&self, maxtime: Option<Unixtime>) -> Result<(), Error>

Check the validity of an event. This is useful if you deserialize an event from the network. If you create an event using new() it should already be trustworthy.

pub fn k_tag_kind(&self) -> Option<EventKind>

Get the k-tag kind, if any

pub fn people(&self) -> Vec<(PublicKeyHex, Option<RelayUrl>, Option<String>)>

If the event refers to people by tag, get all the PublicKeys it refers to along with recommended relay URL and petname for each

pub fn is_tagged(&self, pubkey: &PublicKey) -> bool

If the pubkey is tagged in the event

pub fn people_referenced_in_content(&self) -> Vec<PublicKey>

If the event refers to people within the contents, get all the PublicKeys it refers to within the contents.

pub fn referred_events(&self) -> Vec<EventReference>

All events IDs that this event refers to, whether root, reply, mention, or otherwise along with optional recommended relay URLs

pub fn replies_to(&self) -> Option<EventReference>

Get a reference to another event that this event replies to. An event can only reply to one other event via ‘e’ or ‘a’ tag from a feed-displayable event that is not a Repost.

pub fn replies_to_root(&self) -> Option<EventReference>

If this event replies to a thread, get that threads root event Id if available, along with an optional recommended_relay_url

pub fn mentions(&self) -> Vec<EventReference>

If this event mentions others, get those other event Ids and optional recommended relay Urls

pub fn reacts_to(&self) -> Option<(Id, String, Option<RelayUrl>)>

If this event reacts to another, get that other event’s Id, the reaction content, and an optional Recommended relay Url

pub fn deletes(&self) -> Option<(Vec<Id>, String)>

If this event deletes others, get all the Ids of the events that it deletes along with the reason for the deletion

pub fn zaps(&self) -> Result<Option<ZapDataV1>, Error>

If this event zaps another event, get data about that.

That includes the Id, the amount, and the public key of the provider, all of which should be verified by the caller.

Errors returned from this are not fatal, but may be useful for explaining to a user why a zap receipt is invalid.

pub fn client(&self) -> Option<String>

If this event specifies the client that created it, return that client string

pub fn subject(&self) -> Option<String>

If this event specifies a subject, return that subject string

pub fn title(&self) -> Option<String>

If this event specifies a title, return that title string

pub fn summary(&self) -> Option<String>

If this event specifies a summary, return that summary string

pub fn content_warning(&self) -> Option<String>

If this event specifies a content warning, return that subject string

pub fn parameter(&self) -> Option<String>

If this is a parameterized event, get the parameter

pub fn hashtags(&self) -> Vec<String>

Return all the hashtags this event refers to

pub fn urls(&self) -> Vec<RelayUrl>

Return all the URLs this event refers to

pub fn pow(&self) -> u8

Get the proof-of-work count of leading bits

pub fn delegation(&self) -> EventDelegation

Was this event delegated, was that valid, and if so what is the pubkey of the delegator?

pub fn proxy(&self) -> Option<(&str, &str)>

If the event came through a proxy, get the (Protocol, Id)

impl EventV1

pub fn get_id_from_speedy_bytes(bytes: &[u8]) -> Option<Id>

Read the ID of the event from a speedy encoding without decoding (zero allocation)

Note this function is fragile, if the Event structure is reordered, or if speedy code changes, this will break. Neither should happen.

pub fn get_pubkey_from_speedy_bytes(bytes: &[u8]) -> Option<PublicKey>

Read the pubkey of the event from a speedy encoding without decoding (close to zero allocation, VerifyingKey does stuff I didn’t check)

Note this function is fragile, if the Event structure is reordered, or if speedy code changes, this will break. Neither should happen.

pub fn get_created_at_from_speedy_bytes(bytes: &[u8]) -> Option<Unixtime>

Read the created_at of the event from a speedy encoding without decoding (zero allocation)

Note this function is fragile, if the Event structure is reordered, or if speedy code changes, this will break. Neither should happen.

pub fn get_kind_from_speedy_bytes(bytes: &[u8]) -> Option<EventKind>

Read the kind of the event from a speedy encoding without decoding (zero allocation)

Note this function is fragile, if the Event structure is reordered, or if speedy code changes, this will break. Neither should happen.

pub fn get_ots_from_speedy_bytes(bytes: &[u8]) -> Option<&str>

Read the ots of the event from a speedy encoding without decoding (zero allocation)

Note this function is fragile, if the Event structure is reordered, or if speedy code changes, this will break. Neither should happen.

pub fn get_content_from_speedy_bytes(bytes: &[u8]) -> Option<&str>

Read the content of the event from a speedy encoding without decoding (zero allocation)

Note this function is fragile, if the Event structure is reordered, or if speedy code changes, this will break. Neither should happen.

pub fn tag_search_in_speedy_bytes( bytes: &[u8], re: &Regex, ) -> Result<bool, Error>

Check if any human-readable tag matches the Regex in the speedy encoding without decoding the whole thing (because our Tag representation is so complicated, we do deserialize the tags for now)

Note this function is fragile, if the Event structure is reordered, or if speedy code changes, this will break. Neither should happen.

Trait Implementations

impl Clone for EventV1

fn clone(&self) -> EventV1

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EventV1

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventV1

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<EventV1> for RumorV1

fn from(e: EventV1) -> RumorV1

Converts to this type from the input type.

impl PartialEq for EventV1

fn eq(&self, other: &EventV1) -> 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<'a_, C_: Context> Readable<'a_, C_> for EventV1

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 EventV1

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 EventV1

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 EventV1

impl StructuralPartialEq for EventV1