Struct Event 

pub struct Event {
    pub timestamp: u64,
    pub content: Vec<u8>,
    pub parents: [Hash; 5],
    pub layer: u64,
}

Representation of an event in the Event Graph

Fields

timestamp: u64

Timestamp of the event in whole seconds

content: Vec<u8>

Content of the event

parents: [Hash; 5]

Parent nodes in the event DAG

layer: u64

DAG layer index of the event

Implementations

impl Event

pub async fn new(data: Vec<u8>, event_graph: &EventGraph) -> Self

Create a new event with the given data and an EventGraph reference. The timestamp of the event will be the current time, and the parents will be N_EVENT_PARENTS from the current event graph unreferenced tips. The parents can also include NULL, but this should be handled by the rest of the codebase.

pub async fn with_timestamp( timestamp: u64, data: Vec<u8>, event_graph: &EventGraph, ) -> Self

Same as Event::new() but allows specifying the timestamp explicitly.

pub fn id(&self) -> Hash

Hash the Event to retrieve its ID

pub fn content(&self) -> &[u8]

Return a reference to the event’s content

pub async fn validate( &self, dag: &Tree, genesis_timestamp: u64, days_rotation: u64, overlay: Option<&SledTreeOverlay>, ) -> Result<bool>

Fully validate an event for the correct layout against provided DAG [sled::Tree] reference and enforce relevant age, assuming some possibility for a time drift. Optionally, provide an overlay to use that instead of actual referenced DAG.

pub async fn dag_validate(&self, event_graph: &EventGraph) -> Result<bool>

Fully validate an event for the correct layout against provided EventGraph reference and enforce relevant age, assuming some possibility for a time drift.

pub fn validate_new(&self) -> bool

Validate a new event for the correct layout and enforce relevant age, assuming some possibility for a time drift. Note: This validation does NOT check for recursive references(circles), and should be used as a first quick check.

Trait Implementations

impl AsyncDecodable for Event

where u64: AsyncDecodable, Vec<u8>: AsyncDecodable, [Hash; 5]: AsyncDecodable,

fn decode_async<'life0, 'async_trait, D>( d: &'life0 mut D, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where D: 'async_trait + AsyncRead + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait,

impl AsyncEncodable for Event

where u64: AsyncEncodable, Vec<u8>: AsyncEncodable, [Hash; 5]: AsyncEncodable,

fn encode_async<'life0, 'life1, 'async_trait, S>( &'life0 self, s: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where S: 'async_trait + AsyncWrite + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously encode an object with a well-defined format. Should only ever error if the underlying AsyncWrite errors. Returns the number of bytes written on success.

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl Decodable for Event

where u64: Decodable, Vec<u8>: Decodable, [Hash; 5]: Decodable,

fn decode<D: Read>(d: &mut D) -> Result<Self, Error>

impl Encodable for Event

where u64: Encodable, Vec<u8>: Encodable, [Hash; 5]: Encodable,

fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error>

Encode an object with a well-defined format. Should only ever error if the underlying Write errors. Returns the number of bytes written on success.

impl From<Event> for JsonValue

Available on crate feature event-graph only.

fn from(event: Event) -> JsonValue

Converts to this type from the input type.

impl PartialEq for Event

fn eq(&self, other: &Event) -> 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 StructuralPartialEq for Event